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/Batch/ComputeEnvironment.hs b/gen/Stratosphere/Batch/ComputeEnvironment.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment.hs @@ -0,0 +1,134 @@ +module Stratosphere.Batch.ComputeEnvironment ( + module Exports, ComputeEnvironment(..), mkComputeEnvironment + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.ComputeEnvironment.ComputeResourcesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.ComputeEnvironment.EksConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.ComputeEnvironment.UpdatePolicyProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ComputeEnvironment + = -- | See: + ComputeEnvironment {haddock_workaround_ :: (), + -- | See: + computeEnvironmentName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + computeResources :: (Prelude.Maybe ComputeResourcesProperty), + -- | See: + context :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + eksConfiguration :: (Prelude.Maybe EksConfigurationProperty), + -- | See: + replaceComputeEnvironment :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + serviceRole :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + state :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + type' :: (Value Prelude.Text), + -- | See: + unmanagedvCpus :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + updatePolicy :: (Prelude.Maybe UpdatePolicyProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkComputeEnvironment :: Value Prelude.Text -> ComputeEnvironment +mkComputeEnvironment type' + = ComputeEnvironment + {haddock_workaround_ = (), type' = type', + computeEnvironmentName = Prelude.Nothing, + computeResources = Prelude.Nothing, context = Prelude.Nothing, + eksConfiguration = Prelude.Nothing, + replaceComputeEnvironment = Prelude.Nothing, + serviceRole = Prelude.Nothing, state = Prelude.Nothing, + tags = Prelude.Nothing, unmanagedvCpus = Prelude.Nothing, + updatePolicy = Prelude.Nothing} +instance ToResourceProperties ComputeEnvironment where + toResourceProperties ComputeEnvironment {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "ComputeEnvironmentName" + Prelude.<$> computeEnvironmentName, + (JSON..=) "ComputeResources" Prelude.<$> computeResources, + (JSON..=) "Context" Prelude.<$> context, + (JSON..=) "EksConfiguration" Prelude.<$> eksConfiguration, + (JSON..=) "ReplaceComputeEnvironment" + Prelude.<$> replaceComputeEnvironment, + (JSON..=) "ServiceRole" Prelude.<$> serviceRole, + (JSON..=) "State" Prelude.<$> state, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "UnmanagedvCpus" Prelude.<$> unmanagedvCpus, + (JSON..=) "UpdatePolicy" Prelude.<$> updatePolicy]))} +instance JSON.ToJSON ComputeEnvironment where + toJSON ComputeEnvironment {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "ComputeEnvironmentName" + Prelude.<$> computeEnvironmentName, + (JSON..=) "ComputeResources" Prelude.<$> computeResources, + (JSON..=) "Context" Prelude.<$> context, + (JSON..=) "EksConfiguration" Prelude.<$> eksConfiguration, + (JSON..=) "ReplaceComputeEnvironment" + Prelude.<$> replaceComputeEnvironment, + (JSON..=) "ServiceRole" Prelude.<$> serviceRole, + (JSON..=) "State" Prelude.<$> state, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "UnmanagedvCpus" Prelude.<$> unmanagedvCpus, + (JSON..=) "UpdatePolicy" Prelude.<$> updatePolicy]))) +instance Property "ComputeEnvironmentName" ComputeEnvironment where + type PropertyType "ComputeEnvironmentName" ComputeEnvironment = Value Prelude.Text + set newValue ComputeEnvironment {..} + = ComputeEnvironment + {computeEnvironmentName = Prelude.pure newValue, ..} +instance Property "ComputeResources" ComputeEnvironment where + type PropertyType "ComputeResources" ComputeEnvironment = ComputeResourcesProperty + set newValue ComputeEnvironment {..} + = ComputeEnvironment {computeResources = Prelude.pure newValue, ..} +instance Property "Context" ComputeEnvironment where + type PropertyType "Context" ComputeEnvironment = Value Prelude.Text + set newValue ComputeEnvironment {..} + = ComputeEnvironment {context = Prelude.pure newValue, ..} +instance Property "EksConfiguration" ComputeEnvironment where + type PropertyType "EksConfiguration" ComputeEnvironment = EksConfigurationProperty + set newValue ComputeEnvironment {..} + = ComputeEnvironment {eksConfiguration = Prelude.pure newValue, ..} +instance Property "ReplaceComputeEnvironment" ComputeEnvironment where + type PropertyType "ReplaceComputeEnvironment" ComputeEnvironment = Value Prelude.Bool + set newValue ComputeEnvironment {..} + = ComputeEnvironment + {replaceComputeEnvironment = Prelude.pure newValue, ..} +instance Property "ServiceRole" ComputeEnvironment where + type PropertyType "ServiceRole" ComputeEnvironment = Value Prelude.Text + set newValue ComputeEnvironment {..} + = ComputeEnvironment {serviceRole = Prelude.pure newValue, ..} +instance Property "State" ComputeEnvironment where + type PropertyType "State" ComputeEnvironment = Value Prelude.Text + set newValue ComputeEnvironment {..} + = ComputeEnvironment {state = Prelude.pure newValue, ..} +instance Property "Tags" ComputeEnvironment where + type PropertyType "Tags" ComputeEnvironment = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue ComputeEnvironment {..} + = ComputeEnvironment {tags = Prelude.pure newValue, ..} +instance Property "Type" ComputeEnvironment where + type PropertyType "Type" ComputeEnvironment = Value Prelude.Text + set newValue ComputeEnvironment {..} + = ComputeEnvironment {type' = newValue, ..} +instance Property "UnmanagedvCpus" ComputeEnvironment where + type PropertyType "UnmanagedvCpus" ComputeEnvironment = Value Prelude.Integer + set newValue ComputeEnvironment {..} + = ComputeEnvironment {unmanagedvCpus = Prelude.pure newValue, ..} +instance Property "UpdatePolicy" ComputeEnvironment where + type PropertyType "UpdatePolicy" ComputeEnvironment = UpdatePolicyProperty + set newValue ComputeEnvironment {..} + = ComputeEnvironment {updatePolicy = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/ComputeResourcesProperty.hs b/gen/Stratosphere/Batch/ComputeEnvironment/ComputeResourcesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/ComputeResourcesProperty.hs @@ -0,0 +1,200 @@ +module Stratosphere.Batch.ComputeEnvironment.ComputeResourcesProperty ( + module Exports, ComputeResourcesProperty(..), + mkComputeResourcesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.ComputeEnvironment.Ec2ConfigurationObjectProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ComputeResourcesProperty + = -- | See: + ComputeResourcesProperty {haddock_workaround_ :: (), + -- | See: + allocationStrategy :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + bidPercentage :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + desiredvCpus :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + ec2Configuration :: (Prelude.Maybe [Ec2ConfigurationObjectProperty]), + -- | See: + ec2KeyPair :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + imageId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + instanceRole :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + instanceTypes :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + launchTemplate :: (Prelude.Maybe LaunchTemplateSpecificationProperty), + -- | See: + maxvCpus :: (Value Prelude.Integer), + -- | See: + minvCpus :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + placementGroup :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + securityGroupIds :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + spotIamFleetRole :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + subnets :: (ValueList Prelude.Text), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + type' :: (Value Prelude.Text), + -- | See: + updateToLatestImageVersion :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkComputeResourcesProperty :: + Value Prelude.Integer + -> ValueList Prelude.Text + -> Value Prelude.Text -> ComputeResourcesProperty +mkComputeResourcesProperty maxvCpus subnets type' + = ComputeResourcesProperty + {haddock_workaround_ = (), maxvCpus = maxvCpus, subnets = subnets, + type' = type', allocationStrategy = Prelude.Nothing, + bidPercentage = Prelude.Nothing, desiredvCpus = Prelude.Nothing, + ec2Configuration = Prelude.Nothing, ec2KeyPair = Prelude.Nothing, + imageId = Prelude.Nothing, instanceRole = Prelude.Nothing, + instanceTypes = Prelude.Nothing, launchTemplate = Prelude.Nothing, + minvCpus = Prelude.Nothing, placementGroup = Prelude.Nothing, + securityGroupIds = Prelude.Nothing, + spotIamFleetRole = Prelude.Nothing, tags = Prelude.Nothing, + updateToLatestImageVersion = Prelude.Nothing} +instance ToResourceProperties ComputeResourcesProperty where + toResourceProperties ComputeResourcesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment.ComputeResources", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["MaxvCpus" JSON..= maxvCpus, "Subnets" JSON..= subnets, + "Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "AllocationStrategy" Prelude.<$> allocationStrategy, + (JSON..=) "BidPercentage" Prelude.<$> bidPercentage, + (JSON..=) "DesiredvCpus" Prelude.<$> desiredvCpus, + (JSON..=) "Ec2Configuration" Prelude.<$> ec2Configuration, + (JSON..=) "Ec2KeyPair" Prelude.<$> ec2KeyPair, + (JSON..=) "ImageId" Prelude.<$> imageId, + (JSON..=) "InstanceRole" Prelude.<$> instanceRole, + (JSON..=) "InstanceTypes" Prelude.<$> instanceTypes, + (JSON..=) "LaunchTemplate" Prelude.<$> launchTemplate, + (JSON..=) "MinvCpus" Prelude.<$> minvCpus, + (JSON..=) "PlacementGroup" Prelude.<$> placementGroup, + (JSON..=) "SecurityGroupIds" Prelude.<$> securityGroupIds, + (JSON..=) "SpotIamFleetRole" Prelude.<$> spotIamFleetRole, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "UpdateToLatestImageVersion" + Prelude.<$> updateToLatestImageVersion]))} +instance JSON.ToJSON ComputeResourcesProperty where + toJSON ComputeResourcesProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["MaxvCpus" JSON..= maxvCpus, "Subnets" JSON..= subnets, + "Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "AllocationStrategy" Prelude.<$> allocationStrategy, + (JSON..=) "BidPercentage" Prelude.<$> bidPercentage, + (JSON..=) "DesiredvCpus" Prelude.<$> desiredvCpus, + (JSON..=) "Ec2Configuration" Prelude.<$> ec2Configuration, + (JSON..=) "Ec2KeyPair" Prelude.<$> ec2KeyPair, + (JSON..=) "ImageId" Prelude.<$> imageId, + (JSON..=) "InstanceRole" Prelude.<$> instanceRole, + (JSON..=) "InstanceTypes" Prelude.<$> instanceTypes, + (JSON..=) "LaunchTemplate" Prelude.<$> launchTemplate, + (JSON..=) "MinvCpus" Prelude.<$> minvCpus, + (JSON..=) "PlacementGroup" Prelude.<$> placementGroup, + (JSON..=) "SecurityGroupIds" Prelude.<$> securityGroupIds, + (JSON..=) "SpotIamFleetRole" Prelude.<$> spotIamFleetRole, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "UpdateToLatestImageVersion" + Prelude.<$> updateToLatestImageVersion]))) +instance Property "AllocationStrategy" ComputeResourcesProperty where + type PropertyType "AllocationStrategy" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {allocationStrategy = Prelude.pure newValue, ..} +instance Property "BidPercentage" ComputeResourcesProperty where + type PropertyType "BidPercentage" ComputeResourcesProperty = Value Prelude.Integer + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {bidPercentage = Prelude.pure newValue, ..} +instance Property "DesiredvCpus" ComputeResourcesProperty where + type PropertyType "DesiredvCpus" ComputeResourcesProperty = Value Prelude.Integer + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {desiredvCpus = Prelude.pure newValue, ..} +instance Property "Ec2Configuration" ComputeResourcesProperty where + type PropertyType "Ec2Configuration" ComputeResourcesProperty = [Ec2ConfigurationObjectProperty] + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {ec2Configuration = Prelude.pure newValue, ..} +instance Property "Ec2KeyPair" ComputeResourcesProperty where + type PropertyType "Ec2KeyPair" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {ec2KeyPair = Prelude.pure newValue, ..} +instance Property "ImageId" ComputeResourcesProperty where + type PropertyType "ImageId" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {imageId = Prelude.pure newValue, ..} +instance Property "InstanceRole" ComputeResourcesProperty where + type PropertyType "InstanceRole" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {instanceRole = Prelude.pure newValue, ..} +instance Property "InstanceTypes" ComputeResourcesProperty where + type PropertyType "InstanceTypes" ComputeResourcesProperty = ValueList Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {instanceTypes = Prelude.pure newValue, ..} +instance Property "LaunchTemplate" ComputeResourcesProperty where + type PropertyType "LaunchTemplate" ComputeResourcesProperty = LaunchTemplateSpecificationProperty + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {launchTemplate = Prelude.pure newValue, ..} +instance Property "MaxvCpus" ComputeResourcesProperty where + type PropertyType "MaxvCpus" ComputeResourcesProperty = Value Prelude.Integer + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {maxvCpus = newValue, ..} +instance Property "MinvCpus" ComputeResourcesProperty where + type PropertyType "MinvCpus" ComputeResourcesProperty = Value Prelude.Integer + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {minvCpus = Prelude.pure newValue, ..} +instance Property "PlacementGroup" ComputeResourcesProperty where + type PropertyType "PlacementGroup" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {placementGroup = Prelude.pure newValue, ..} +instance Property "SecurityGroupIds" ComputeResourcesProperty where + type PropertyType "SecurityGroupIds" ComputeResourcesProperty = ValueList Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {securityGroupIds = Prelude.pure newValue, ..} +instance Property "SpotIamFleetRole" ComputeResourcesProperty where + type PropertyType "SpotIamFleetRole" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {spotIamFleetRole = Prelude.pure newValue, ..} +instance Property "Subnets" ComputeResourcesProperty where + type PropertyType "Subnets" ComputeResourcesProperty = ValueList Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {subnets = newValue, ..} +instance Property "Tags" ComputeResourcesProperty where + type PropertyType "Tags" ComputeResourcesProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {tags = Prelude.pure newValue, ..} +instance Property "Type" ComputeResourcesProperty where + type PropertyType "Type" ComputeResourcesProperty = Value Prelude.Text + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty {type' = newValue, ..} +instance Property "UpdateToLatestImageVersion" ComputeResourcesProperty where + type PropertyType "UpdateToLatestImageVersion" ComputeResourcesProperty = Value Prelude.Bool + set newValue ComputeResourcesProperty {..} + = ComputeResourcesProperty + {updateToLatestImageVersion = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/ComputeResourcesProperty.hs-boot b/gen/Stratosphere/Batch/ComputeEnvironment/ComputeResourcesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/ComputeResourcesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ComputeEnvironment.ComputeResourcesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ComputeResourcesProperty :: Prelude.Type +instance ToResourceProperties ComputeResourcesProperty +instance Prelude.Eq ComputeResourcesProperty +instance Prelude.Show ComputeResourcesProperty +instance JSON.ToJSON ComputeResourcesProperty diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/Ec2ConfigurationObjectProperty.hs b/gen/Stratosphere/Batch/ComputeEnvironment/Ec2ConfigurationObjectProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/Ec2ConfigurationObjectProperty.hs @@ -0,0 +1,62 @@ +module Stratosphere.Batch.ComputeEnvironment.Ec2ConfigurationObjectProperty ( + Ec2ConfigurationObjectProperty(..), + mkEc2ConfigurationObjectProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data Ec2ConfigurationObjectProperty + = -- | See: + Ec2ConfigurationObjectProperty {haddock_workaround_ :: (), + -- | See: + imageIdOverride :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + imageKubernetesVersion :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + imageType :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEc2ConfigurationObjectProperty :: + Value Prelude.Text -> Ec2ConfigurationObjectProperty +mkEc2ConfigurationObjectProperty imageType + = Ec2ConfigurationObjectProperty + {haddock_workaround_ = (), imageType = imageType, + imageIdOverride = Prelude.Nothing, + imageKubernetesVersion = Prelude.Nothing} +instance ToResourceProperties Ec2ConfigurationObjectProperty where + toResourceProperties Ec2ConfigurationObjectProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment.Ec2ConfigurationObject", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ImageType" JSON..= imageType] + (Prelude.catMaybes + [(JSON..=) "ImageIdOverride" Prelude.<$> imageIdOverride, + (JSON..=) "ImageKubernetesVersion" + Prelude.<$> imageKubernetesVersion]))} +instance JSON.ToJSON Ec2ConfigurationObjectProperty where + toJSON Ec2ConfigurationObjectProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ImageType" JSON..= imageType] + (Prelude.catMaybes + [(JSON..=) "ImageIdOverride" Prelude.<$> imageIdOverride, + (JSON..=) "ImageKubernetesVersion" + Prelude.<$> imageKubernetesVersion]))) +instance Property "ImageIdOverride" Ec2ConfigurationObjectProperty where + type PropertyType "ImageIdOverride" Ec2ConfigurationObjectProperty = Value Prelude.Text + set newValue Ec2ConfigurationObjectProperty {..} + = Ec2ConfigurationObjectProperty + {imageIdOverride = Prelude.pure newValue, ..} +instance Property "ImageKubernetesVersion" Ec2ConfigurationObjectProperty where + type PropertyType "ImageKubernetesVersion" Ec2ConfigurationObjectProperty = Value Prelude.Text + set newValue Ec2ConfigurationObjectProperty {..} + = Ec2ConfigurationObjectProperty + {imageKubernetesVersion = Prelude.pure newValue, ..} +instance Property "ImageType" Ec2ConfigurationObjectProperty where + type PropertyType "ImageType" Ec2ConfigurationObjectProperty = Value Prelude.Text + set newValue Ec2ConfigurationObjectProperty {..} + = Ec2ConfigurationObjectProperty {imageType = newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/Ec2ConfigurationObjectProperty.hs-boot b/gen/Stratosphere/Batch/ComputeEnvironment/Ec2ConfigurationObjectProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/Ec2ConfigurationObjectProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ComputeEnvironment.Ec2ConfigurationObjectProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data Ec2ConfigurationObjectProperty :: Prelude.Type +instance ToResourceProperties Ec2ConfigurationObjectProperty +instance Prelude.Eq Ec2ConfigurationObjectProperty +instance Prelude.Show Ec2ConfigurationObjectProperty +instance JSON.ToJSON Ec2ConfigurationObjectProperty diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/EksConfigurationProperty.hs b/gen/Stratosphere/Batch/ComputeEnvironment/EksConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/EksConfigurationProperty.hs @@ -0,0 +1,43 @@ +module Stratosphere.Batch.ComputeEnvironment.EksConfigurationProperty ( + EksConfigurationProperty(..), mkEksConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksConfigurationProperty + = -- | See: + EksConfigurationProperty {haddock_workaround_ :: (), + -- | See: + eksClusterArn :: (Value Prelude.Text), + -- | See: + kubernetesNamespace :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksConfigurationProperty :: + Value Prelude.Text + -> Value Prelude.Text -> EksConfigurationProperty +mkEksConfigurationProperty eksClusterArn kubernetesNamespace + = EksConfigurationProperty + {haddock_workaround_ = (), eksClusterArn = eksClusterArn, + kubernetesNamespace = kubernetesNamespace} +instance ToResourceProperties EksConfigurationProperty where + toResourceProperties EksConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment.EksConfiguration", + supportsTags = Prelude.False, + properties = ["EksClusterArn" JSON..= eksClusterArn, + "KubernetesNamespace" JSON..= kubernetesNamespace]} +instance JSON.ToJSON EksConfigurationProperty where + toJSON EksConfigurationProperty {..} + = JSON.object + ["EksClusterArn" JSON..= eksClusterArn, + "KubernetesNamespace" JSON..= kubernetesNamespace] +instance Property "EksClusterArn" EksConfigurationProperty where + type PropertyType "EksClusterArn" EksConfigurationProperty = Value Prelude.Text + set newValue EksConfigurationProperty {..} + = EksConfigurationProperty {eksClusterArn = newValue, ..} +instance Property "KubernetesNamespace" EksConfigurationProperty where + type PropertyType "KubernetesNamespace" EksConfigurationProperty = Value Prelude.Text + set newValue EksConfigurationProperty {..} + = EksConfigurationProperty {kubernetesNamespace = newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/EksConfigurationProperty.hs-boot b/gen/Stratosphere/Batch/ComputeEnvironment/EksConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/EksConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ComputeEnvironment.EksConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksConfigurationProperty :: Prelude.Type +instance ToResourceProperties EksConfigurationProperty +instance Prelude.Eq EksConfigurationProperty +instance Prelude.Show EksConfigurationProperty +instance JSON.ToJSON EksConfigurationProperty diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationOverrideProperty.hs b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationOverrideProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationOverrideProperty.hs @@ -0,0 +1,79 @@ +module Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationOverrideProperty ( + LaunchTemplateSpecificationOverrideProperty(..), + mkLaunchTemplateSpecificationOverrideProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LaunchTemplateSpecificationOverrideProperty + = -- | See: + LaunchTemplateSpecificationOverrideProperty {haddock_workaround_ :: (), + -- | See: + launchTemplateId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + launchTemplateName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + targetInstanceTypes :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + userdataType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + version :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLaunchTemplateSpecificationOverrideProperty :: + LaunchTemplateSpecificationOverrideProperty +mkLaunchTemplateSpecificationOverrideProperty + = LaunchTemplateSpecificationOverrideProperty + {haddock_workaround_ = (), launchTemplateId = Prelude.Nothing, + launchTemplateName = Prelude.Nothing, + targetInstanceTypes = Prelude.Nothing, + userdataType = Prelude.Nothing, version = Prelude.Nothing} +instance ToResourceProperties LaunchTemplateSpecificationOverrideProperty where + toResourceProperties + LaunchTemplateSpecificationOverrideProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment.LaunchTemplateSpecificationOverride", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LaunchTemplateId" Prelude.<$> launchTemplateId, + (JSON..=) "LaunchTemplateName" Prelude.<$> launchTemplateName, + (JSON..=) "TargetInstanceTypes" Prelude.<$> targetInstanceTypes, + (JSON..=) "UserdataType" Prelude.<$> userdataType, + (JSON..=) "Version" Prelude.<$> version])} +instance JSON.ToJSON LaunchTemplateSpecificationOverrideProperty where + toJSON LaunchTemplateSpecificationOverrideProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LaunchTemplateId" Prelude.<$> launchTemplateId, + (JSON..=) "LaunchTemplateName" Prelude.<$> launchTemplateName, + (JSON..=) "TargetInstanceTypes" Prelude.<$> targetInstanceTypes, + (JSON..=) "UserdataType" Prelude.<$> userdataType, + (JSON..=) "Version" Prelude.<$> version])) +instance Property "LaunchTemplateId" LaunchTemplateSpecificationOverrideProperty where + type PropertyType "LaunchTemplateId" LaunchTemplateSpecificationOverrideProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationOverrideProperty {..} + = LaunchTemplateSpecificationOverrideProperty + {launchTemplateId = Prelude.pure newValue, ..} +instance Property "LaunchTemplateName" LaunchTemplateSpecificationOverrideProperty where + type PropertyType "LaunchTemplateName" LaunchTemplateSpecificationOverrideProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationOverrideProperty {..} + = LaunchTemplateSpecificationOverrideProperty + {launchTemplateName = Prelude.pure newValue, ..} +instance Property "TargetInstanceTypes" LaunchTemplateSpecificationOverrideProperty where + type PropertyType "TargetInstanceTypes" LaunchTemplateSpecificationOverrideProperty = ValueList Prelude.Text + set newValue LaunchTemplateSpecificationOverrideProperty {..} + = LaunchTemplateSpecificationOverrideProperty + {targetInstanceTypes = Prelude.pure newValue, ..} +instance Property "UserdataType" LaunchTemplateSpecificationOverrideProperty where + type PropertyType "UserdataType" LaunchTemplateSpecificationOverrideProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationOverrideProperty {..} + = LaunchTemplateSpecificationOverrideProperty + {userdataType = Prelude.pure newValue, ..} +instance Property "Version" LaunchTemplateSpecificationOverrideProperty where + type PropertyType "Version" LaunchTemplateSpecificationOverrideProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationOverrideProperty {..} + = LaunchTemplateSpecificationOverrideProperty + {version = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationOverrideProperty.hs-boot b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationOverrideProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationOverrideProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationOverrideProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LaunchTemplateSpecificationOverrideProperty :: Prelude.Type +instance ToResourceProperties LaunchTemplateSpecificationOverrideProperty +instance Prelude.Eq LaunchTemplateSpecificationOverrideProperty +instance Prelude.Show LaunchTemplateSpecificationOverrideProperty +instance JSON.ToJSON LaunchTemplateSpecificationOverrideProperty diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationProperty.hs b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationProperty.hs @@ -0,0 +1,78 @@ +module Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationProperty ( + module Exports, LaunchTemplateSpecificationProperty(..), + mkLaunchTemplateSpecificationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationOverrideProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LaunchTemplateSpecificationProperty + = -- | See: + LaunchTemplateSpecificationProperty {haddock_workaround_ :: (), + -- | See: + launchTemplateId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + launchTemplateName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + overrides :: (Prelude.Maybe [LaunchTemplateSpecificationOverrideProperty]), + -- | See: + userdataType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + version :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLaunchTemplateSpecificationProperty :: + LaunchTemplateSpecificationProperty +mkLaunchTemplateSpecificationProperty + = LaunchTemplateSpecificationProperty + {haddock_workaround_ = (), launchTemplateId = Prelude.Nothing, + launchTemplateName = Prelude.Nothing, overrides = Prelude.Nothing, + userdataType = Prelude.Nothing, version = Prelude.Nothing} +instance ToResourceProperties LaunchTemplateSpecificationProperty where + toResourceProperties LaunchTemplateSpecificationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment.LaunchTemplateSpecification", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LaunchTemplateId" Prelude.<$> launchTemplateId, + (JSON..=) "LaunchTemplateName" Prelude.<$> launchTemplateName, + (JSON..=) "Overrides" Prelude.<$> overrides, + (JSON..=) "UserdataType" Prelude.<$> userdataType, + (JSON..=) "Version" Prelude.<$> version])} +instance JSON.ToJSON LaunchTemplateSpecificationProperty where + toJSON LaunchTemplateSpecificationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LaunchTemplateId" Prelude.<$> launchTemplateId, + (JSON..=) "LaunchTemplateName" Prelude.<$> launchTemplateName, + (JSON..=) "Overrides" Prelude.<$> overrides, + (JSON..=) "UserdataType" Prelude.<$> userdataType, + (JSON..=) "Version" Prelude.<$> version])) +instance Property "LaunchTemplateId" LaunchTemplateSpecificationProperty where + type PropertyType "LaunchTemplateId" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {launchTemplateId = Prelude.pure newValue, ..} +instance Property "LaunchTemplateName" LaunchTemplateSpecificationProperty where + type PropertyType "LaunchTemplateName" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {launchTemplateName = Prelude.pure newValue, ..} +instance Property "Overrides" LaunchTemplateSpecificationProperty where + type PropertyType "Overrides" LaunchTemplateSpecificationProperty = [LaunchTemplateSpecificationOverrideProperty] + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {overrides = Prelude.pure newValue, ..} +instance Property "UserdataType" LaunchTemplateSpecificationProperty where + type PropertyType "UserdataType" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {userdataType = Prelude.pure newValue, ..} +instance Property "Version" LaunchTemplateSpecificationProperty where + type PropertyType "Version" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {version = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationProperty.hs-boot b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/LaunchTemplateSpecificationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LaunchTemplateSpecificationProperty :: Prelude.Type +instance ToResourceProperties LaunchTemplateSpecificationProperty +instance Prelude.Eq LaunchTemplateSpecificationProperty +instance Prelude.Show LaunchTemplateSpecificationProperty +instance JSON.ToJSON LaunchTemplateSpecificationProperty diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/UpdatePolicyProperty.hs b/gen/Stratosphere/Batch/ComputeEnvironment/UpdatePolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/UpdatePolicyProperty.hs @@ -0,0 +1,52 @@ +module Stratosphere.Batch.ComputeEnvironment.UpdatePolicyProperty ( + UpdatePolicyProperty(..), mkUpdatePolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data UpdatePolicyProperty + = -- | See: + UpdatePolicyProperty {haddock_workaround_ :: (), + -- | See: + jobExecutionTimeoutMinutes :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + terminateJobsOnUpdate :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkUpdatePolicyProperty :: UpdatePolicyProperty +mkUpdatePolicyProperty + = UpdatePolicyProperty + {haddock_workaround_ = (), + jobExecutionTimeoutMinutes = Prelude.Nothing, + terminateJobsOnUpdate = Prelude.Nothing} +instance ToResourceProperties UpdatePolicyProperty where + toResourceProperties UpdatePolicyProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ComputeEnvironment.UpdatePolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "JobExecutionTimeoutMinutes" + Prelude.<$> jobExecutionTimeoutMinutes, + (JSON..=) "TerminateJobsOnUpdate" + Prelude.<$> terminateJobsOnUpdate])} +instance JSON.ToJSON UpdatePolicyProperty where + toJSON UpdatePolicyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "JobExecutionTimeoutMinutes" + Prelude.<$> jobExecutionTimeoutMinutes, + (JSON..=) "TerminateJobsOnUpdate" + Prelude.<$> terminateJobsOnUpdate])) +instance Property "JobExecutionTimeoutMinutes" UpdatePolicyProperty where + type PropertyType "JobExecutionTimeoutMinutes" UpdatePolicyProperty = Value Prelude.Integer + set newValue UpdatePolicyProperty {..} + = UpdatePolicyProperty + {jobExecutionTimeoutMinutes = Prelude.pure newValue, ..} +instance Property "TerminateJobsOnUpdate" UpdatePolicyProperty where + type PropertyType "TerminateJobsOnUpdate" UpdatePolicyProperty = Value Prelude.Bool + set newValue UpdatePolicyProperty {..} + = UpdatePolicyProperty + {terminateJobsOnUpdate = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ComputeEnvironment/UpdatePolicyProperty.hs-boot b/gen/Stratosphere/Batch/ComputeEnvironment/UpdatePolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ComputeEnvironment/UpdatePolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ComputeEnvironment.UpdatePolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data UpdatePolicyProperty :: Prelude.Type +instance ToResourceProperties UpdatePolicyProperty +instance Prelude.Eq UpdatePolicyProperty +instance Prelude.Show UpdatePolicyProperty +instance JSON.ToJSON UpdatePolicyProperty diff --git a/gen/Stratosphere/Batch/ConsumableResource.hs b/gen/Stratosphere/Batch/ConsumableResource.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ConsumableResource.hs @@ -0,0 +1,68 @@ +module Stratosphere.Batch.ConsumableResource ( + ConsumableResource(..), mkConsumableResource + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ConsumableResource + = -- | See: + ConsumableResource {haddock_workaround_ :: (), + -- | See: + consumableResourceName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + resourceType :: (Value Prelude.Text), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + totalQuantity :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkConsumableResource :: + Value Prelude.Text -> Value Prelude.Integer -> ConsumableResource +mkConsumableResource resourceType totalQuantity + = ConsumableResource + {haddock_workaround_ = (), resourceType = resourceType, + totalQuantity = totalQuantity, + consumableResourceName = Prelude.Nothing, tags = Prelude.Nothing} +instance ToResourceProperties ConsumableResource where + toResourceProperties ConsumableResource {..} + = ResourceProperties + {awsType = "AWS::Batch::ConsumableResource", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ResourceType" JSON..= resourceType, + "TotalQuantity" JSON..= totalQuantity] + (Prelude.catMaybes + [(JSON..=) "ConsumableResourceName" + Prelude.<$> consumableResourceName, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON ConsumableResource where + toJSON ConsumableResource {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ResourceType" JSON..= resourceType, + "TotalQuantity" JSON..= totalQuantity] + (Prelude.catMaybes + [(JSON..=) "ConsumableResourceName" + Prelude.<$> consumableResourceName, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "ConsumableResourceName" ConsumableResource where + type PropertyType "ConsumableResourceName" ConsumableResource = Value Prelude.Text + set newValue ConsumableResource {..} + = ConsumableResource + {consumableResourceName = Prelude.pure newValue, ..} +instance Property "ResourceType" ConsumableResource where + type PropertyType "ResourceType" ConsumableResource = Value Prelude.Text + set newValue ConsumableResource {..} + = ConsumableResource {resourceType = newValue, ..} +instance Property "Tags" ConsumableResource where + type PropertyType "Tags" ConsumableResource = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue ConsumableResource {..} + = ConsumableResource {tags = Prelude.pure newValue, ..} +instance Property "TotalQuantity" ConsumableResource where + type PropertyType "TotalQuantity" ConsumableResource = Value Prelude.Integer + set newValue ConsumableResource {..} + = ConsumableResource {totalQuantity = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition.hs b/gen/Stratosphere/Batch/JobDefinition.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition.hs @@ -0,0 +1,175 @@ +module Stratosphere.Batch.JobDefinition ( + module Exports, JobDefinition(..), mkJobDefinition + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ConsumableResourcePropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ContainerPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EcsPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.JobTimeoutProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.NodePropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ResourceRetentionPolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RetryStrategyProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data JobDefinition + = -- | See: + JobDefinition {haddock_workaround_ :: (), + -- | See: + consumableResourceProperties :: (Prelude.Maybe ConsumableResourcePropertiesProperty), + -- | See: + containerProperties :: (Prelude.Maybe ContainerPropertiesProperty), + -- | See: + ecsProperties :: (Prelude.Maybe EcsPropertiesProperty), + -- | See: + eksProperties :: (Prelude.Maybe EksPropertiesProperty), + -- | See: + jobDefinitionName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + nodeProperties :: (Prelude.Maybe NodePropertiesProperty), + -- | See: + parameters :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + platformCapabilities :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + propagateTags :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + resourceRetentionPolicy :: (Prelude.Maybe ResourceRetentionPolicyProperty), + -- | See: + retryStrategy :: (Prelude.Maybe RetryStrategyProperty), + -- | See: + schedulingPriority :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + timeout :: (Prelude.Maybe JobTimeoutProperty), + -- | See: + type' :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkJobDefinition :: Value Prelude.Text -> JobDefinition +mkJobDefinition type' + = JobDefinition + {haddock_workaround_ = (), type' = type', + consumableResourceProperties = Prelude.Nothing, + containerProperties = Prelude.Nothing, + ecsProperties = Prelude.Nothing, eksProperties = Prelude.Nothing, + jobDefinitionName = Prelude.Nothing, + nodeProperties = Prelude.Nothing, parameters = Prelude.Nothing, + platformCapabilities = Prelude.Nothing, + propagateTags = Prelude.Nothing, + resourceRetentionPolicy = Prelude.Nothing, + retryStrategy = Prelude.Nothing, + schedulingPriority = Prelude.Nothing, tags = Prelude.Nothing, + timeout = Prelude.Nothing} +instance ToResourceProperties JobDefinition where + toResourceProperties JobDefinition {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "ConsumableResourceProperties" + Prelude.<$> consumableResourceProperties, + (JSON..=) "ContainerProperties" Prelude.<$> containerProperties, + (JSON..=) "EcsProperties" Prelude.<$> ecsProperties, + (JSON..=) "EksProperties" Prelude.<$> eksProperties, + (JSON..=) "JobDefinitionName" Prelude.<$> jobDefinitionName, + (JSON..=) "NodeProperties" Prelude.<$> nodeProperties, + (JSON..=) "Parameters" Prelude.<$> parameters, + (JSON..=) "PlatformCapabilities" Prelude.<$> platformCapabilities, + (JSON..=) "PropagateTags" Prelude.<$> propagateTags, + (JSON..=) "ResourceRetentionPolicy" + Prelude.<$> resourceRetentionPolicy, + (JSON..=) "RetryStrategy" Prelude.<$> retryStrategy, + (JSON..=) "SchedulingPriority" Prelude.<$> schedulingPriority, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "Timeout" Prelude.<$> timeout]))} +instance JSON.ToJSON JobDefinition where + toJSON JobDefinition {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "ConsumableResourceProperties" + Prelude.<$> consumableResourceProperties, + (JSON..=) "ContainerProperties" Prelude.<$> containerProperties, + (JSON..=) "EcsProperties" Prelude.<$> ecsProperties, + (JSON..=) "EksProperties" Prelude.<$> eksProperties, + (JSON..=) "JobDefinitionName" Prelude.<$> jobDefinitionName, + (JSON..=) "NodeProperties" Prelude.<$> nodeProperties, + (JSON..=) "Parameters" Prelude.<$> parameters, + (JSON..=) "PlatformCapabilities" Prelude.<$> platformCapabilities, + (JSON..=) "PropagateTags" Prelude.<$> propagateTags, + (JSON..=) "ResourceRetentionPolicy" + Prelude.<$> resourceRetentionPolicy, + (JSON..=) "RetryStrategy" Prelude.<$> retryStrategy, + (JSON..=) "SchedulingPriority" Prelude.<$> schedulingPriority, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "Timeout" Prelude.<$> timeout]))) +instance Property "ConsumableResourceProperties" JobDefinition where + type PropertyType "ConsumableResourceProperties" JobDefinition = ConsumableResourcePropertiesProperty + set newValue JobDefinition {..} + = JobDefinition + {consumableResourceProperties = Prelude.pure newValue, ..} +instance Property "ContainerProperties" JobDefinition where + type PropertyType "ContainerProperties" JobDefinition = ContainerPropertiesProperty + set newValue JobDefinition {..} + = JobDefinition {containerProperties = Prelude.pure newValue, ..} +instance Property "EcsProperties" JobDefinition where + type PropertyType "EcsProperties" JobDefinition = EcsPropertiesProperty + set newValue JobDefinition {..} + = JobDefinition {ecsProperties = Prelude.pure newValue, ..} +instance Property "EksProperties" JobDefinition where + type PropertyType "EksProperties" JobDefinition = EksPropertiesProperty + set newValue JobDefinition {..} + = JobDefinition {eksProperties = Prelude.pure newValue, ..} +instance Property "JobDefinitionName" JobDefinition where + type PropertyType "JobDefinitionName" JobDefinition = Value Prelude.Text + set newValue JobDefinition {..} + = JobDefinition {jobDefinitionName = Prelude.pure newValue, ..} +instance Property "NodeProperties" JobDefinition where + type PropertyType "NodeProperties" JobDefinition = NodePropertiesProperty + set newValue JobDefinition {..} + = JobDefinition {nodeProperties = Prelude.pure newValue, ..} +instance Property "Parameters" JobDefinition where + type PropertyType "Parameters" JobDefinition = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue JobDefinition {..} + = JobDefinition {parameters = Prelude.pure newValue, ..} +instance Property "PlatformCapabilities" JobDefinition where + type PropertyType "PlatformCapabilities" JobDefinition = ValueList Prelude.Text + set newValue JobDefinition {..} + = JobDefinition {platformCapabilities = Prelude.pure newValue, ..} +instance Property "PropagateTags" JobDefinition where + type PropertyType "PropagateTags" JobDefinition = Value Prelude.Bool + set newValue JobDefinition {..} + = JobDefinition {propagateTags = Prelude.pure newValue, ..} +instance Property "ResourceRetentionPolicy" JobDefinition where + type PropertyType "ResourceRetentionPolicy" JobDefinition = ResourceRetentionPolicyProperty + set newValue JobDefinition {..} + = JobDefinition + {resourceRetentionPolicy = Prelude.pure newValue, ..} +instance Property "RetryStrategy" JobDefinition where + type PropertyType "RetryStrategy" JobDefinition = RetryStrategyProperty + set newValue JobDefinition {..} + = JobDefinition {retryStrategy = Prelude.pure newValue, ..} +instance Property "SchedulingPriority" JobDefinition where + type PropertyType "SchedulingPriority" JobDefinition = Value Prelude.Integer + set newValue JobDefinition {..} + = JobDefinition {schedulingPriority = Prelude.pure newValue, ..} +instance Property "Tags" JobDefinition where + type PropertyType "Tags" JobDefinition = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue JobDefinition {..} + = JobDefinition {tags = Prelude.pure newValue, ..} +instance Property "Timeout" JobDefinition where + type PropertyType "Timeout" JobDefinition = JobTimeoutProperty + set newValue JobDefinition {..} + = JobDefinition {timeout = Prelude.pure newValue, ..} +instance Property "Type" JobDefinition where + type PropertyType "Type" JobDefinition = Value Prelude.Text + set newValue JobDefinition {..} + = JobDefinition {type' = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ConsumableResourcePropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourcePropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourcePropertiesProperty.hs @@ -0,0 +1,38 @@ +module Stratosphere.Batch.JobDefinition.ConsumableResourcePropertiesProperty ( + module Exports, ConsumableResourcePropertiesProperty(..), + mkConsumableResourcePropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ConsumableResourceRequirementProperty as Exports +import Stratosphere.ResourceProperties +data ConsumableResourcePropertiesProperty + = -- | See: + ConsumableResourcePropertiesProperty {haddock_workaround_ :: (), + -- | See: + consumableResourceList :: [ConsumableResourceRequirementProperty]} + deriving stock (Prelude.Eq, Prelude.Show) +mkConsumableResourcePropertiesProperty :: + [ConsumableResourceRequirementProperty] + -> ConsumableResourcePropertiesProperty +mkConsumableResourcePropertiesProperty consumableResourceList + = ConsumableResourcePropertiesProperty + {haddock_workaround_ = (), + consumableResourceList = consumableResourceList} +instance ToResourceProperties ConsumableResourcePropertiesProperty where + toResourceProperties ConsumableResourcePropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.ConsumableResourceProperties", + supportsTags = Prelude.False, + properties = ["ConsumableResourceList" + JSON..= consumableResourceList]} +instance JSON.ToJSON ConsumableResourcePropertiesProperty where + toJSON ConsumableResourcePropertiesProperty {..} + = JSON.object + ["ConsumableResourceList" JSON..= consumableResourceList] +instance Property "ConsumableResourceList" ConsumableResourcePropertiesProperty where + type PropertyType "ConsumableResourceList" ConsumableResourcePropertiesProperty = [ConsumableResourceRequirementProperty] + set newValue ConsumableResourcePropertiesProperty {..} + = ConsumableResourcePropertiesProperty + {consumableResourceList = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ConsumableResourcePropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourcePropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourcePropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.ConsumableResourcePropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ConsumableResourcePropertiesProperty :: Prelude.Type +instance ToResourceProperties ConsumableResourcePropertiesProperty +instance Prelude.Eq ConsumableResourcePropertiesProperty +instance Prelude.Show ConsumableResourcePropertiesProperty +instance JSON.ToJSON ConsumableResourcePropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/ConsumableResourceRequirementProperty.hs b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourceRequirementProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourceRequirementProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobDefinition.ConsumableResourceRequirementProperty ( + ConsumableResourceRequirementProperty(..), + mkConsumableResourceRequirementProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ConsumableResourceRequirementProperty + = -- | See: + ConsumableResourceRequirementProperty {haddock_workaround_ :: (), + -- | See: + consumableResource :: (Value Prelude.Text), + -- | See: + quantity :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkConsumableResourceRequirementProperty :: + Value Prelude.Text + -> Value Prelude.Integer -> ConsumableResourceRequirementProperty +mkConsumableResourceRequirementProperty consumableResource quantity + = ConsumableResourceRequirementProperty + {haddock_workaround_ = (), consumableResource = consumableResource, + quantity = quantity} +instance ToResourceProperties ConsumableResourceRequirementProperty where + toResourceProperties ConsumableResourceRequirementProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.ConsumableResourceRequirement", + supportsTags = Prelude.False, + properties = ["ConsumableResource" JSON..= consumableResource, + "Quantity" JSON..= quantity]} +instance JSON.ToJSON ConsumableResourceRequirementProperty where + toJSON ConsumableResourceRequirementProperty {..} + = JSON.object + ["ConsumableResource" JSON..= consumableResource, + "Quantity" JSON..= quantity] +instance Property "ConsumableResource" ConsumableResourceRequirementProperty where + type PropertyType "ConsumableResource" ConsumableResourceRequirementProperty = Value Prelude.Text + set newValue ConsumableResourceRequirementProperty {..} + = ConsumableResourceRequirementProperty + {consumableResource = newValue, ..} +instance Property "Quantity" ConsumableResourceRequirementProperty where + type PropertyType "Quantity" ConsumableResourceRequirementProperty = Value Prelude.Integer + set newValue ConsumableResourceRequirementProperty {..} + = ConsumableResourceRequirementProperty {quantity = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ConsumableResourceRequirementProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourceRequirementProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ConsumableResourceRequirementProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.ConsumableResourceRequirementProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ConsumableResourceRequirementProperty :: Prelude.Type +instance ToResourceProperties ConsumableResourceRequirementProperty +instance Prelude.Eq ConsumableResourceRequirementProperty +instance Prelude.Show ConsumableResourceRequirementProperty +instance JSON.ToJSON ConsumableResourceRequirementProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/ContainerPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/ContainerPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ContainerPropertiesProperty.hs @@ -0,0 +1,265 @@ +module Stratosphere.Batch.JobDefinition.ContainerPropertiesProperty ( + module Exports, ContainerPropertiesProperty(..), + mkContainerPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EnvironmentProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EphemeralStorageProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.FargatePlatformConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.LinuxParametersProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.LogConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.MountPointProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.NetworkConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RepositoryCredentialsProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ResourceRequirementProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RuntimePlatformProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.SecretProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.UlimitProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.VolumeProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ContainerPropertiesProperty + = -- | See: + ContainerPropertiesProperty {haddock_workaround_ :: (), + -- | See: + command :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + enableExecuteCommand :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + environment :: (Prelude.Maybe [EnvironmentProperty]), + -- | See: + ephemeralStorage :: (Prelude.Maybe EphemeralStorageProperty), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + fargatePlatformConfiguration :: (Prelude.Maybe FargatePlatformConfigurationProperty), + -- | See: + image :: (Value Prelude.Text), + -- | See: + jobRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + linuxParameters :: (Prelude.Maybe LinuxParametersProperty), + -- | See: + logConfiguration :: (Prelude.Maybe LogConfigurationProperty), + -- | See: + memory :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + mountPoints :: (Prelude.Maybe [MountPointProperty]), + -- | See: + networkConfiguration :: (Prelude.Maybe NetworkConfigurationProperty), + -- | See: + privileged :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + readonlyRootFilesystem :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + repositoryCredentials :: (Prelude.Maybe RepositoryCredentialsProperty), + -- | See: + resourceRequirements :: (Prelude.Maybe [ResourceRequirementProperty]), + -- | See: + runtimePlatform :: (Prelude.Maybe RuntimePlatformProperty), + -- | See: + secrets :: (Prelude.Maybe [SecretProperty]), + -- | See: + ulimits :: (Prelude.Maybe [UlimitProperty]), + -- | See: + user :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + vcpus :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + volumes :: (Prelude.Maybe [VolumeProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkContainerPropertiesProperty :: + Value Prelude.Text -> ContainerPropertiesProperty +mkContainerPropertiesProperty image + = ContainerPropertiesProperty + {haddock_workaround_ = (), image = image, + command = Prelude.Nothing, enableExecuteCommand = Prelude.Nothing, + environment = Prelude.Nothing, ephemeralStorage = Prelude.Nothing, + executionRoleArn = Prelude.Nothing, + fargatePlatformConfiguration = Prelude.Nothing, + jobRoleArn = Prelude.Nothing, linuxParameters = Prelude.Nothing, + logConfiguration = Prelude.Nothing, memory = Prelude.Nothing, + mountPoints = Prelude.Nothing, + networkConfiguration = Prelude.Nothing, + privileged = Prelude.Nothing, + readonlyRootFilesystem = Prelude.Nothing, + repositoryCredentials = Prelude.Nothing, + resourceRequirements = Prelude.Nothing, + runtimePlatform = Prelude.Nothing, secrets = Prelude.Nothing, + ulimits = Prelude.Nothing, user = Prelude.Nothing, + vcpus = Prelude.Nothing, volumes = Prelude.Nothing} +instance ToResourceProperties ContainerPropertiesProperty where + toResourceProperties ContainerPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.ContainerProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Command" Prelude.<$> command, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "Environment" Prelude.<$> environment, + (JSON..=) "EphemeralStorage" Prelude.<$> ephemeralStorage, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "FargatePlatformConfiguration" + Prelude.<$> fargatePlatformConfiguration, + (JSON..=) "JobRoleArn" Prelude.<$> jobRoleArn, + (JSON..=) "LinuxParameters" Prelude.<$> linuxParameters, + (JSON..=) "LogConfiguration" Prelude.<$> logConfiguration, + (JSON..=) "Memory" Prelude.<$> memory, + (JSON..=) "MountPoints" Prelude.<$> mountPoints, + (JSON..=) "NetworkConfiguration" Prelude.<$> networkConfiguration, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadonlyRootFilesystem" + Prelude.<$> readonlyRootFilesystem, + (JSON..=) "RepositoryCredentials" + Prelude.<$> repositoryCredentials, + (JSON..=) "ResourceRequirements" Prelude.<$> resourceRequirements, + (JSON..=) "RuntimePlatform" Prelude.<$> runtimePlatform, + (JSON..=) "Secrets" Prelude.<$> secrets, + (JSON..=) "Ulimits" Prelude.<$> ulimits, + (JSON..=) "User" Prelude.<$> user, + (JSON..=) "Vcpus" Prelude.<$> vcpus, + (JSON..=) "Volumes" Prelude.<$> volumes]))} +instance JSON.ToJSON ContainerPropertiesProperty where + toJSON ContainerPropertiesProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Command" Prelude.<$> command, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "Environment" Prelude.<$> environment, + (JSON..=) "EphemeralStorage" Prelude.<$> ephemeralStorage, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "FargatePlatformConfiguration" + Prelude.<$> fargatePlatformConfiguration, + (JSON..=) "JobRoleArn" Prelude.<$> jobRoleArn, + (JSON..=) "LinuxParameters" Prelude.<$> linuxParameters, + (JSON..=) "LogConfiguration" Prelude.<$> logConfiguration, + (JSON..=) "Memory" Prelude.<$> memory, + (JSON..=) "MountPoints" Prelude.<$> mountPoints, + (JSON..=) "NetworkConfiguration" Prelude.<$> networkConfiguration, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadonlyRootFilesystem" + Prelude.<$> readonlyRootFilesystem, + (JSON..=) "RepositoryCredentials" + Prelude.<$> repositoryCredentials, + (JSON..=) "ResourceRequirements" Prelude.<$> resourceRequirements, + (JSON..=) "RuntimePlatform" Prelude.<$> runtimePlatform, + (JSON..=) "Secrets" Prelude.<$> secrets, + (JSON..=) "Ulimits" Prelude.<$> ulimits, + (JSON..=) "User" Prelude.<$> user, + (JSON..=) "Vcpus" Prelude.<$> vcpus, + (JSON..=) "Volumes" Prelude.<$> volumes]))) +instance Property "Command" ContainerPropertiesProperty where + type PropertyType "Command" ContainerPropertiesProperty = ValueList Prelude.Text + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {command = Prelude.pure newValue, ..} +instance Property "EnableExecuteCommand" ContainerPropertiesProperty where + type PropertyType "EnableExecuteCommand" ContainerPropertiesProperty = Value Prelude.Bool + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {enableExecuteCommand = Prelude.pure newValue, ..} +instance Property "Environment" ContainerPropertiesProperty where + type PropertyType "Environment" ContainerPropertiesProperty = [EnvironmentProperty] + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {environment = Prelude.pure newValue, ..} +instance Property "EphemeralStorage" ContainerPropertiesProperty where + type PropertyType "EphemeralStorage" ContainerPropertiesProperty = EphemeralStorageProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {ephemeralStorage = Prelude.pure newValue, ..} +instance Property "ExecutionRoleArn" ContainerPropertiesProperty where + type PropertyType "ExecutionRoleArn" ContainerPropertiesProperty = Value Prelude.Text + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {executionRoleArn = Prelude.pure newValue, ..} +instance Property "FargatePlatformConfiguration" ContainerPropertiesProperty where + type PropertyType "FargatePlatformConfiguration" ContainerPropertiesProperty = FargatePlatformConfigurationProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {fargatePlatformConfiguration = Prelude.pure newValue, ..} +instance Property "Image" ContainerPropertiesProperty where + type PropertyType "Image" ContainerPropertiesProperty = Value Prelude.Text + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {image = newValue, ..} +instance Property "JobRoleArn" ContainerPropertiesProperty where + type PropertyType "JobRoleArn" ContainerPropertiesProperty = Value Prelude.Text + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {jobRoleArn = Prelude.pure newValue, ..} +instance Property "LinuxParameters" ContainerPropertiesProperty where + type PropertyType "LinuxParameters" ContainerPropertiesProperty = LinuxParametersProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {linuxParameters = Prelude.pure newValue, ..} +instance Property "LogConfiguration" ContainerPropertiesProperty where + type PropertyType "LogConfiguration" ContainerPropertiesProperty = LogConfigurationProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {logConfiguration = Prelude.pure newValue, ..} +instance Property "Memory" ContainerPropertiesProperty where + type PropertyType "Memory" ContainerPropertiesProperty = Value Prelude.Integer + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {memory = Prelude.pure newValue, ..} +instance Property "MountPoints" ContainerPropertiesProperty where + type PropertyType "MountPoints" ContainerPropertiesProperty = [MountPointProperty] + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {mountPoints = Prelude.pure newValue, ..} +instance Property "NetworkConfiguration" ContainerPropertiesProperty where + type PropertyType "NetworkConfiguration" ContainerPropertiesProperty = NetworkConfigurationProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {networkConfiguration = Prelude.pure newValue, ..} +instance Property "Privileged" ContainerPropertiesProperty where + type PropertyType "Privileged" ContainerPropertiesProperty = Value Prelude.Bool + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {privileged = Prelude.pure newValue, ..} +instance Property "ReadonlyRootFilesystem" ContainerPropertiesProperty where + type PropertyType "ReadonlyRootFilesystem" ContainerPropertiesProperty = Value Prelude.Bool + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {readonlyRootFilesystem = Prelude.pure newValue, ..} +instance Property "RepositoryCredentials" ContainerPropertiesProperty where + type PropertyType "RepositoryCredentials" ContainerPropertiesProperty = RepositoryCredentialsProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {repositoryCredentials = Prelude.pure newValue, ..} +instance Property "ResourceRequirements" ContainerPropertiesProperty where + type PropertyType "ResourceRequirements" ContainerPropertiesProperty = [ResourceRequirementProperty] + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {resourceRequirements = Prelude.pure newValue, ..} +instance Property "RuntimePlatform" ContainerPropertiesProperty where + type PropertyType "RuntimePlatform" ContainerPropertiesProperty = RuntimePlatformProperty + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty + {runtimePlatform = Prelude.pure newValue, ..} +instance Property "Secrets" ContainerPropertiesProperty where + type PropertyType "Secrets" ContainerPropertiesProperty = [SecretProperty] + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {secrets = Prelude.pure newValue, ..} +instance Property "Ulimits" ContainerPropertiesProperty where + type PropertyType "Ulimits" ContainerPropertiesProperty = [UlimitProperty] + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {ulimits = Prelude.pure newValue, ..} +instance Property "User" ContainerPropertiesProperty where + type PropertyType "User" ContainerPropertiesProperty = Value Prelude.Text + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {user = Prelude.pure newValue, ..} +instance Property "Vcpus" ContainerPropertiesProperty where + type PropertyType "Vcpus" ContainerPropertiesProperty = Value Prelude.Integer + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {vcpus = Prelude.pure newValue, ..} +instance Property "Volumes" ContainerPropertiesProperty where + type PropertyType "Volumes" ContainerPropertiesProperty = [VolumeProperty] + set newValue ContainerPropertiesProperty {..} + = ContainerPropertiesProperty {volumes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ContainerPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/ContainerPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ContainerPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.ContainerPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ContainerPropertiesProperty :: Prelude.Type +instance ToResourceProperties ContainerPropertiesProperty +instance Prelude.Eq ContainerPropertiesProperty +instance Prelude.Show ContainerPropertiesProperty +instance JSON.ToJSON ContainerPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/DeviceProperty.hs b/gen/Stratosphere/Batch/JobDefinition/DeviceProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/DeviceProperty.hs @@ -0,0 +1,53 @@ +module Stratosphere.Batch.JobDefinition.DeviceProperty ( + DeviceProperty(..), mkDeviceProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data DeviceProperty + = -- | See: + DeviceProperty {haddock_workaround_ :: (), + -- | See: + containerPath :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + hostPath :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + permissions :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkDeviceProperty :: DeviceProperty +mkDeviceProperty + = DeviceProperty + {haddock_workaround_ = (), containerPath = Prelude.Nothing, + hostPath = Prelude.Nothing, permissions = Prelude.Nothing} +instance ToResourceProperties DeviceProperty where + toResourceProperties DeviceProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Device", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ContainerPath" Prelude.<$> containerPath, + (JSON..=) "HostPath" Prelude.<$> hostPath, + (JSON..=) "Permissions" Prelude.<$> permissions])} +instance JSON.ToJSON DeviceProperty where + toJSON DeviceProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ContainerPath" Prelude.<$> containerPath, + (JSON..=) "HostPath" Prelude.<$> hostPath, + (JSON..=) "Permissions" Prelude.<$> permissions])) +instance Property "ContainerPath" DeviceProperty where + type PropertyType "ContainerPath" DeviceProperty = Value Prelude.Text + set newValue DeviceProperty {..} + = DeviceProperty {containerPath = Prelude.pure newValue, ..} +instance Property "HostPath" DeviceProperty where + type PropertyType "HostPath" DeviceProperty = Value Prelude.Text + set newValue DeviceProperty {..} + = DeviceProperty {hostPath = Prelude.pure newValue, ..} +instance Property "Permissions" DeviceProperty where + type PropertyType "Permissions" DeviceProperty = ValueList Prelude.Text + set newValue DeviceProperty {..} + = DeviceProperty {permissions = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/DeviceProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/DeviceProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/DeviceProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.DeviceProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data DeviceProperty :: Prelude.Type +instance ToResourceProperties DeviceProperty +instance Prelude.Eq DeviceProperty +instance Prelude.Show DeviceProperty +instance JSON.ToJSON DeviceProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EFSAuthorizationConfigProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EFSAuthorizationConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EFSAuthorizationConfigProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.Batch.JobDefinition.EFSAuthorizationConfigProperty ( + EFSAuthorizationConfigProperty(..), + mkEFSAuthorizationConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EFSAuthorizationConfigProperty + = -- | See: + EFSAuthorizationConfigProperty {haddock_workaround_ :: (), + -- | See: + accessPointId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + iam :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEFSAuthorizationConfigProperty :: EFSAuthorizationConfigProperty +mkEFSAuthorizationConfigProperty + = EFSAuthorizationConfigProperty + {haddock_workaround_ = (), accessPointId = Prelude.Nothing, + iam = Prelude.Nothing} +instance ToResourceProperties EFSAuthorizationConfigProperty where + toResourceProperties EFSAuthorizationConfigProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EFSAuthorizationConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AccessPointId" Prelude.<$> accessPointId, + (JSON..=) "Iam" Prelude.<$> iam])} +instance JSON.ToJSON EFSAuthorizationConfigProperty where + toJSON EFSAuthorizationConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AccessPointId" Prelude.<$> accessPointId, + (JSON..=) "Iam" Prelude.<$> iam])) +instance Property "AccessPointId" EFSAuthorizationConfigProperty where + type PropertyType "AccessPointId" EFSAuthorizationConfigProperty = Value Prelude.Text + set newValue EFSAuthorizationConfigProperty {..} + = EFSAuthorizationConfigProperty + {accessPointId = Prelude.pure newValue, ..} +instance Property "Iam" EFSAuthorizationConfigProperty where + type PropertyType "Iam" EFSAuthorizationConfigProperty = Value Prelude.Text + set newValue EFSAuthorizationConfigProperty {..} + = EFSAuthorizationConfigProperty {iam = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EFSAuthorizationConfigProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EFSAuthorizationConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EFSAuthorizationConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EFSAuthorizationConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EFSAuthorizationConfigProperty :: Prelude.Type +instance ToResourceProperties EFSAuthorizationConfigProperty +instance Prelude.Eq EFSAuthorizationConfigProperty +instance Prelude.Show EFSAuthorizationConfigProperty +instance JSON.ToJSON EFSAuthorizationConfigProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EFSVolumeConfigurationProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EFSVolumeConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EFSVolumeConfigurationProperty.hs @@ -0,0 +1,83 @@ +module Stratosphere.Batch.JobDefinition.EFSVolumeConfigurationProperty ( + module Exports, EFSVolumeConfigurationProperty(..), + mkEFSVolumeConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EFSAuthorizationConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EFSVolumeConfigurationProperty + = -- | See: + EFSVolumeConfigurationProperty {haddock_workaround_ :: (), + -- | See: + authorizationConfig :: (Prelude.Maybe EFSAuthorizationConfigProperty), + -- | See: + fileSystemId :: (Value Prelude.Text), + -- | See: + rootDirectory :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + transitEncryption :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + transitEncryptionPort :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEFSVolumeConfigurationProperty :: + Value Prelude.Text -> EFSVolumeConfigurationProperty +mkEFSVolumeConfigurationProperty fileSystemId + = EFSVolumeConfigurationProperty + {haddock_workaround_ = (), fileSystemId = fileSystemId, + authorizationConfig = Prelude.Nothing, + rootDirectory = Prelude.Nothing, + transitEncryption = Prelude.Nothing, + transitEncryptionPort = Prelude.Nothing} +instance ToResourceProperties EFSVolumeConfigurationProperty where + toResourceProperties EFSVolumeConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EFSVolumeConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["FileSystemId" JSON..= fileSystemId] + (Prelude.catMaybes + [(JSON..=) "AuthorizationConfig" Prelude.<$> authorizationConfig, + (JSON..=) "RootDirectory" Prelude.<$> rootDirectory, + (JSON..=) "TransitEncryption" Prelude.<$> transitEncryption, + (JSON..=) "TransitEncryptionPort" + Prelude.<$> transitEncryptionPort]))} +instance JSON.ToJSON EFSVolumeConfigurationProperty where + toJSON EFSVolumeConfigurationProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["FileSystemId" JSON..= fileSystemId] + (Prelude.catMaybes + [(JSON..=) "AuthorizationConfig" Prelude.<$> authorizationConfig, + (JSON..=) "RootDirectory" Prelude.<$> rootDirectory, + (JSON..=) "TransitEncryption" Prelude.<$> transitEncryption, + (JSON..=) "TransitEncryptionPort" + Prelude.<$> transitEncryptionPort]))) +instance Property "AuthorizationConfig" EFSVolumeConfigurationProperty where + type PropertyType "AuthorizationConfig" EFSVolumeConfigurationProperty = EFSAuthorizationConfigProperty + set newValue EFSVolumeConfigurationProperty {..} + = EFSVolumeConfigurationProperty + {authorizationConfig = Prelude.pure newValue, ..} +instance Property "FileSystemId" EFSVolumeConfigurationProperty where + type PropertyType "FileSystemId" EFSVolumeConfigurationProperty = Value Prelude.Text + set newValue EFSVolumeConfigurationProperty {..} + = EFSVolumeConfigurationProperty {fileSystemId = newValue, ..} +instance Property "RootDirectory" EFSVolumeConfigurationProperty where + type PropertyType "RootDirectory" EFSVolumeConfigurationProperty = Value Prelude.Text + set newValue EFSVolumeConfigurationProperty {..} + = EFSVolumeConfigurationProperty + {rootDirectory = Prelude.pure newValue, ..} +instance Property "TransitEncryption" EFSVolumeConfigurationProperty where + type PropertyType "TransitEncryption" EFSVolumeConfigurationProperty = Value Prelude.Text + set newValue EFSVolumeConfigurationProperty {..} + = EFSVolumeConfigurationProperty + {transitEncryption = Prelude.pure newValue, ..} +instance Property "TransitEncryptionPort" EFSVolumeConfigurationProperty where + type PropertyType "TransitEncryptionPort" EFSVolumeConfigurationProperty = Value Prelude.Integer + set newValue EFSVolumeConfigurationProperty {..} + = EFSVolumeConfigurationProperty + {transitEncryptionPort = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EFSVolumeConfigurationProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EFSVolumeConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EFSVolumeConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EFSVolumeConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EFSVolumeConfigurationProperty :: Prelude.Type +instance ToResourceProperties EFSVolumeConfigurationProperty +instance Prelude.Eq EFSVolumeConfigurationProperty +instance Prelude.Show EFSVolumeConfigurationProperty +instance JSON.ToJSON EFSVolumeConfigurationProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EcsPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EcsPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EcsPropertiesProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.Batch.JobDefinition.EcsPropertiesProperty ( + module Exports, EcsPropertiesProperty(..), mkEcsPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EcsTaskPropertiesProperty as Exports +import Stratosphere.ResourceProperties +data EcsPropertiesProperty + = -- | See: + EcsPropertiesProperty {haddock_workaround_ :: (), + -- | See: + taskProperties :: [EcsTaskPropertiesProperty]} + deriving stock (Prelude.Eq, Prelude.Show) +mkEcsPropertiesProperty :: + [EcsTaskPropertiesProperty] -> EcsPropertiesProperty +mkEcsPropertiesProperty taskProperties + = EcsPropertiesProperty + {haddock_workaround_ = (), taskProperties = taskProperties} +instance ToResourceProperties EcsPropertiesProperty where + toResourceProperties EcsPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EcsProperties", + supportsTags = Prelude.False, + properties = ["TaskProperties" JSON..= taskProperties]} +instance JSON.ToJSON EcsPropertiesProperty where + toJSON EcsPropertiesProperty {..} + = JSON.object ["TaskProperties" JSON..= taskProperties] +instance Property "TaskProperties" EcsPropertiesProperty where + type PropertyType "TaskProperties" EcsPropertiesProperty = [EcsTaskPropertiesProperty] + set newValue EcsPropertiesProperty {..} + = EcsPropertiesProperty {taskProperties = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EcsPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EcsPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EcsPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EcsPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EcsPropertiesProperty :: Prelude.Type +instance ToResourceProperties EcsPropertiesProperty +instance Prelude.Eq EcsPropertiesProperty +instance Prelude.Show EcsPropertiesProperty +instance JSON.ToJSON EcsPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EcsTaskPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EcsTaskPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EcsTaskPropertiesProperty.hs @@ -0,0 +1,137 @@ +module Stratosphere.Batch.JobDefinition.EcsTaskPropertiesProperty ( + module Exports, EcsTaskPropertiesProperty(..), + mkEcsTaskPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EphemeralStorageProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.NetworkConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RuntimePlatformProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.TaskContainerPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.VolumeProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EcsTaskPropertiesProperty + = -- | See: + EcsTaskPropertiesProperty {haddock_workaround_ :: (), + -- | See: + containers :: (Prelude.Maybe [TaskContainerPropertiesProperty]), + -- | See: + enableExecuteCommand :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + ephemeralStorage :: (Prelude.Maybe EphemeralStorageProperty), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + ipcMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + networkConfiguration :: (Prelude.Maybe NetworkConfigurationProperty), + -- | See: + pidMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + platformVersion :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + runtimePlatform :: (Prelude.Maybe RuntimePlatformProperty), + -- | See: + taskRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + volumes :: (Prelude.Maybe [VolumeProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkEcsTaskPropertiesProperty :: EcsTaskPropertiesProperty +mkEcsTaskPropertiesProperty + = EcsTaskPropertiesProperty + {haddock_workaround_ = (), containers = Prelude.Nothing, + enableExecuteCommand = Prelude.Nothing, + ephemeralStorage = Prelude.Nothing, + executionRoleArn = Prelude.Nothing, ipcMode = Prelude.Nothing, + networkConfiguration = Prelude.Nothing, pidMode = Prelude.Nothing, + platformVersion = Prelude.Nothing, + runtimePlatform = Prelude.Nothing, taskRoleArn = Prelude.Nothing, + volumes = Prelude.Nothing} +instance ToResourceProperties EcsTaskPropertiesProperty where + toResourceProperties EcsTaskPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EcsTaskProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Containers" Prelude.<$> containers, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "EphemeralStorage" Prelude.<$> ephemeralStorage, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "IpcMode" Prelude.<$> ipcMode, + (JSON..=) "NetworkConfiguration" Prelude.<$> networkConfiguration, + (JSON..=) "PidMode" Prelude.<$> pidMode, + (JSON..=) "PlatformVersion" Prelude.<$> platformVersion, + (JSON..=) "RuntimePlatform" Prelude.<$> runtimePlatform, + (JSON..=) "TaskRoleArn" Prelude.<$> taskRoleArn, + (JSON..=) "Volumes" Prelude.<$> volumes])} +instance JSON.ToJSON EcsTaskPropertiesProperty where + toJSON EcsTaskPropertiesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Containers" Prelude.<$> containers, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "EphemeralStorage" Prelude.<$> ephemeralStorage, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "IpcMode" Prelude.<$> ipcMode, + (JSON..=) "NetworkConfiguration" Prelude.<$> networkConfiguration, + (JSON..=) "PidMode" Prelude.<$> pidMode, + (JSON..=) "PlatformVersion" Prelude.<$> platformVersion, + (JSON..=) "RuntimePlatform" Prelude.<$> runtimePlatform, + (JSON..=) "TaskRoleArn" Prelude.<$> taskRoleArn, + (JSON..=) "Volumes" Prelude.<$> volumes])) +instance Property "Containers" EcsTaskPropertiesProperty where + type PropertyType "Containers" EcsTaskPropertiesProperty = [TaskContainerPropertiesProperty] + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {containers = Prelude.pure newValue, ..} +instance Property "EnableExecuteCommand" EcsTaskPropertiesProperty where + type PropertyType "EnableExecuteCommand" EcsTaskPropertiesProperty = Value Prelude.Bool + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {enableExecuteCommand = Prelude.pure newValue, ..} +instance Property "EphemeralStorage" EcsTaskPropertiesProperty where + type PropertyType "EphemeralStorage" EcsTaskPropertiesProperty = EphemeralStorageProperty + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {ephemeralStorage = Prelude.pure newValue, ..} +instance Property "ExecutionRoleArn" EcsTaskPropertiesProperty where + type PropertyType "ExecutionRoleArn" EcsTaskPropertiesProperty = Value Prelude.Text + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {executionRoleArn = Prelude.pure newValue, ..} +instance Property "IpcMode" EcsTaskPropertiesProperty where + type PropertyType "IpcMode" EcsTaskPropertiesProperty = Value Prelude.Text + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty {ipcMode = Prelude.pure newValue, ..} +instance Property "NetworkConfiguration" EcsTaskPropertiesProperty where + type PropertyType "NetworkConfiguration" EcsTaskPropertiesProperty = NetworkConfigurationProperty + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {networkConfiguration = Prelude.pure newValue, ..} +instance Property "PidMode" EcsTaskPropertiesProperty where + type PropertyType "PidMode" EcsTaskPropertiesProperty = Value Prelude.Text + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty {pidMode = Prelude.pure newValue, ..} +instance Property "PlatformVersion" EcsTaskPropertiesProperty where + type PropertyType "PlatformVersion" EcsTaskPropertiesProperty = Value Prelude.Text + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {platformVersion = Prelude.pure newValue, ..} +instance Property "RuntimePlatform" EcsTaskPropertiesProperty where + type PropertyType "RuntimePlatform" EcsTaskPropertiesProperty = RuntimePlatformProperty + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {runtimePlatform = Prelude.pure newValue, ..} +instance Property "TaskRoleArn" EcsTaskPropertiesProperty where + type PropertyType "TaskRoleArn" EcsTaskPropertiesProperty = Value Prelude.Text + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty + {taskRoleArn = Prelude.pure newValue, ..} +instance Property "Volumes" EcsTaskPropertiesProperty where + type PropertyType "Volumes" EcsTaskPropertiesProperty = [VolumeProperty] + set newValue EcsTaskPropertiesProperty {..} + = EcsTaskPropertiesProperty {volumes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EcsTaskPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EcsTaskPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EcsTaskPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EcsTaskPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EcsTaskPropertiesProperty :: Prelude.Type +instance ToResourceProperties EcsTaskPropertiesProperty +instance Prelude.Eq EcsTaskPropertiesProperty +instance Prelude.Show EcsTaskPropertiesProperty +instance JSON.ToJSON EcsTaskPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerEnvironmentVariableProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksContainerEnvironmentVariableProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerEnvironmentVariableProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.Batch.JobDefinition.EksContainerEnvironmentVariableProperty ( + EksContainerEnvironmentVariableProperty(..), + mkEksContainerEnvironmentVariableProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksContainerEnvironmentVariableProperty + = -- | See: + EksContainerEnvironmentVariableProperty {haddock_workaround_ :: (), + -- | See: + name :: (Value Prelude.Text), + -- | See: + value :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksContainerEnvironmentVariableProperty :: + Value Prelude.Text -> EksContainerEnvironmentVariableProperty +mkEksContainerEnvironmentVariableProperty name + = EksContainerEnvironmentVariableProperty + {haddock_workaround_ = (), name = name, value = Prelude.Nothing} +instance ToResourceProperties EksContainerEnvironmentVariableProperty where + toResourceProperties EksContainerEnvironmentVariableProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksContainerEnvironmentVariable", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Name" JSON..= name] + (Prelude.catMaybes [(JSON..=) "Value" Prelude.<$> value]))} +instance JSON.ToJSON EksContainerEnvironmentVariableProperty where + toJSON EksContainerEnvironmentVariableProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Name" JSON..= name] + (Prelude.catMaybes [(JSON..=) "Value" Prelude.<$> value]))) +instance Property "Name" EksContainerEnvironmentVariableProperty where + type PropertyType "Name" EksContainerEnvironmentVariableProperty = Value Prelude.Text + set newValue EksContainerEnvironmentVariableProperty {..} + = EksContainerEnvironmentVariableProperty {name = newValue, ..} +instance Property "Value" EksContainerEnvironmentVariableProperty where + type PropertyType "Value" EksContainerEnvironmentVariableProperty = Value Prelude.Text + set newValue EksContainerEnvironmentVariableProperty {..} + = EksContainerEnvironmentVariableProperty + {value = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerEnvironmentVariableProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksContainerEnvironmentVariableProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerEnvironmentVariableProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksContainerEnvironmentVariableProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksContainerEnvironmentVariableProperty :: Prelude.Type +instance ToResourceProperties EksContainerEnvironmentVariableProperty +instance Prelude.Eq EksContainerEnvironmentVariableProperty +instance Prelude.Show EksContainerEnvironmentVariableProperty +instance JSON.ToJSON EksContainerEnvironmentVariableProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksContainerProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerProperty.hs @@ -0,0 +1,113 @@ +module Stratosphere.Batch.JobDefinition.EksContainerProperty ( + module Exports, EksContainerProperty(..), mkEksContainerProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksContainerEnvironmentVariableProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksContainerResourceRequirementsProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksContainerSecurityContextProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksContainerVolumeMountProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksContainerProperty + = -- | See: + EksContainerProperty {haddock_workaround_ :: (), + -- | See: + args :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + command :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + env :: (Prelude.Maybe [EksContainerEnvironmentVariableProperty]), + -- | See: + image :: (Value Prelude.Text), + -- | See: + imagePullPolicy :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + resources :: (Prelude.Maybe EksContainerResourceRequirementsProperty), + -- | See: + securityContext :: (Prelude.Maybe EksContainerSecurityContextProperty), + -- | See: + volumeMounts :: (Prelude.Maybe [EksContainerVolumeMountProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksContainerProperty :: + Value Prelude.Text -> EksContainerProperty +mkEksContainerProperty image + = EksContainerProperty + {haddock_workaround_ = (), image = image, args = Prelude.Nothing, + command = Prelude.Nothing, env = Prelude.Nothing, + imagePullPolicy = Prelude.Nothing, name = Prelude.Nothing, + resources = Prelude.Nothing, securityContext = Prelude.Nothing, + volumeMounts = Prelude.Nothing} +instance ToResourceProperties EksContainerProperty where + toResourceProperties EksContainerProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksContainer", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Args" Prelude.<$> args, + (JSON..=) "Command" Prelude.<$> command, + (JSON..=) "Env" Prelude.<$> env, + (JSON..=) "ImagePullPolicy" Prelude.<$> imagePullPolicy, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Resources" Prelude.<$> resources, + (JSON..=) "SecurityContext" Prelude.<$> securityContext, + (JSON..=) "VolumeMounts" Prelude.<$> volumeMounts]))} +instance JSON.ToJSON EksContainerProperty where + toJSON EksContainerProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Args" Prelude.<$> args, + (JSON..=) "Command" Prelude.<$> command, + (JSON..=) "Env" Prelude.<$> env, + (JSON..=) "ImagePullPolicy" Prelude.<$> imagePullPolicy, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Resources" Prelude.<$> resources, + (JSON..=) "SecurityContext" Prelude.<$> securityContext, + (JSON..=) "VolumeMounts" Prelude.<$> volumeMounts]))) +instance Property "Args" EksContainerProperty where + type PropertyType "Args" EksContainerProperty = ValueList Prelude.Text + set newValue EksContainerProperty {..} + = EksContainerProperty {args = Prelude.pure newValue, ..} +instance Property "Command" EksContainerProperty where + type PropertyType "Command" EksContainerProperty = ValueList Prelude.Text + set newValue EksContainerProperty {..} + = EksContainerProperty {command = Prelude.pure newValue, ..} +instance Property "Env" EksContainerProperty where + type PropertyType "Env" EksContainerProperty = [EksContainerEnvironmentVariableProperty] + set newValue EksContainerProperty {..} + = EksContainerProperty {env = Prelude.pure newValue, ..} +instance Property "Image" EksContainerProperty where + type PropertyType "Image" EksContainerProperty = Value Prelude.Text + set newValue EksContainerProperty {..} + = EksContainerProperty {image = newValue, ..} +instance Property "ImagePullPolicy" EksContainerProperty where + type PropertyType "ImagePullPolicy" EksContainerProperty = Value Prelude.Text + set newValue EksContainerProperty {..} + = EksContainerProperty + {imagePullPolicy = Prelude.pure newValue, ..} +instance Property "Name" EksContainerProperty where + type PropertyType "Name" EksContainerProperty = Value Prelude.Text + set newValue EksContainerProperty {..} + = EksContainerProperty {name = Prelude.pure newValue, ..} +instance Property "Resources" EksContainerProperty where + type PropertyType "Resources" EksContainerProperty = EksContainerResourceRequirementsProperty + set newValue EksContainerProperty {..} + = EksContainerProperty {resources = Prelude.pure newValue, ..} +instance Property "SecurityContext" EksContainerProperty where + type PropertyType "SecurityContext" EksContainerProperty = EksContainerSecurityContextProperty + set newValue EksContainerProperty {..} + = EksContainerProperty + {securityContext = Prelude.pure newValue, ..} +instance Property "VolumeMounts" EksContainerProperty where + type PropertyType "VolumeMounts" EksContainerProperty = [EksContainerVolumeMountProperty] + set newValue EksContainerProperty {..} + = EksContainerProperty {volumeMounts = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksContainerProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksContainerProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksContainerProperty :: Prelude.Type +instance ToResourceProperties EksContainerProperty +instance Prelude.Eq EksContainerProperty +instance Prelude.Show EksContainerProperty +instance JSON.ToJSON EksContainerProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerResourceRequirementsProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksContainerResourceRequirementsProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerResourceRequirementsProperty.hs @@ -0,0 +1,49 @@ +module Stratosphere.Batch.JobDefinition.EksContainerResourceRequirementsProperty ( + EksContainerResourceRequirementsProperty(..), + mkEksContainerResourceRequirementsProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksContainerResourceRequirementsProperty + = -- | See: + EksContainerResourceRequirementsProperty {haddock_workaround_ :: (), + -- | See: + limits :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + requests :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text)))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksContainerResourceRequirementsProperty :: + EksContainerResourceRequirementsProperty +mkEksContainerResourceRequirementsProperty + = EksContainerResourceRequirementsProperty + {haddock_workaround_ = (), limits = Prelude.Nothing, + requests = Prelude.Nothing} +instance ToResourceProperties EksContainerResourceRequirementsProperty where + toResourceProperties EksContainerResourceRequirementsProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksContainerResourceRequirements", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Limits" Prelude.<$> limits, + (JSON..=) "Requests" Prelude.<$> requests])} +instance JSON.ToJSON EksContainerResourceRequirementsProperty where + toJSON EksContainerResourceRequirementsProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Limits" Prelude.<$> limits, + (JSON..=) "Requests" Prelude.<$> requests])) +instance Property "Limits" EksContainerResourceRequirementsProperty where + type PropertyType "Limits" EksContainerResourceRequirementsProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue EksContainerResourceRequirementsProperty {..} + = EksContainerResourceRequirementsProperty + {limits = Prelude.pure newValue, ..} +instance Property "Requests" EksContainerResourceRequirementsProperty where + type PropertyType "Requests" EksContainerResourceRequirementsProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue EksContainerResourceRequirementsProperty {..} + = EksContainerResourceRequirementsProperty + {requests = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerResourceRequirementsProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksContainerResourceRequirementsProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerResourceRequirementsProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksContainerResourceRequirementsProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksContainerResourceRequirementsProperty :: Prelude.Type +instance ToResourceProperties EksContainerResourceRequirementsProperty +instance Prelude.Eq EksContainerResourceRequirementsProperty +instance Prelude.Show EksContainerResourceRequirementsProperty +instance JSON.ToJSON EksContainerResourceRequirementsProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerSecurityContextProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksContainerSecurityContextProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerSecurityContextProperty.hs @@ -0,0 +1,93 @@ +module Stratosphere.Batch.JobDefinition.EksContainerSecurityContextProperty ( + EksContainerSecurityContextProperty(..), + mkEksContainerSecurityContextProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksContainerSecurityContextProperty + = -- | See: + EksContainerSecurityContextProperty {haddock_workaround_ :: (), + -- | See: + allowPrivilegeEscalation :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + privileged :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + readOnlyRootFilesystem :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + runAsGroup :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + runAsNonRoot :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + runAsUser :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksContainerSecurityContextProperty :: + EksContainerSecurityContextProperty +mkEksContainerSecurityContextProperty + = EksContainerSecurityContextProperty + {haddock_workaround_ = (), + allowPrivilegeEscalation = Prelude.Nothing, + privileged = Prelude.Nothing, + readOnlyRootFilesystem = Prelude.Nothing, + runAsGroup = Prelude.Nothing, runAsNonRoot = Prelude.Nothing, + runAsUser = Prelude.Nothing} +instance ToResourceProperties EksContainerSecurityContextProperty where + toResourceProperties EksContainerSecurityContextProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksContainerSecurityContext", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AllowPrivilegeEscalation" + Prelude.<$> allowPrivilegeEscalation, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadOnlyRootFilesystem" + Prelude.<$> readOnlyRootFilesystem, + (JSON..=) "RunAsGroup" Prelude.<$> runAsGroup, + (JSON..=) "RunAsNonRoot" Prelude.<$> runAsNonRoot, + (JSON..=) "RunAsUser" Prelude.<$> runAsUser])} +instance JSON.ToJSON EksContainerSecurityContextProperty where + toJSON EksContainerSecurityContextProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AllowPrivilegeEscalation" + Prelude.<$> allowPrivilegeEscalation, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadOnlyRootFilesystem" + Prelude.<$> readOnlyRootFilesystem, + (JSON..=) "RunAsGroup" Prelude.<$> runAsGroup, + (JSON..=) "RunAsNonRoot" Prelude.<$> runAsNonRoot, + (JSON..=) "RunAsUser" Prelude.<$> runAsUser])) +instance Property "AllowPrivilegeEscalation" EksContainerSecurityContextProperty where + type PropertyType "AllowPrivilegeEscalation" EksContainerSecurityContextProperty = Value Prelude.Bool + set newValue EksContainerSecurityContextProperty {..} + = EksContainerSecurityContextProperty + {allowPrivilegeEscalation = Prelude.pure newValue, ..} +instance Property "Privileged" EksContainerSecurityContextProperty where + type PropertyType "Privileged" EksContainerSecurityContextProperty = Value Prelude.Bool + set newValue EksContainerSecurityContextProperty {..} + = EksContainerSecurityContextProperty + {privileged = Prelude.pure newValue, ..} +instance Property "ReadOnlyRootFilesystem" EksContainerSecurityContextProperty where + type PropertyType "ReadOnlyRootFilesystem" EksContainerSecurityContextProperty = Value Prelude.Bool + set newValue EksContainerSecurityContextProperty {..} + = EksContainerSecurityContextProperty + {readOnlyRootFilesystem = Prelude.pure newValue, ..} +instance Property "RunAsGroup" EksContainerSecurityContextProperty where + type PropertyType "RunAsGroup" EksContainerSecurityContextProperty = Value Prelude.Integer + set newValue EksContainerSecurityContextProperty {..} + = EksContainerSecurityContextProperty + {runAsGroup = Prelude.pure newValue, ..} +instance Property "RunAsNonRoot" EksContainerSecurityContextProperty where + type PropertyType "RunAsNonRoot" EksContainerSecurityContextProperty = Value Prelude.Bool + set newValue EksContainerSecurityContextProperty {..} + = EksContainerSecurityContextProperty + {runAsNonRoot = Prelude.pure newValue, ..} +instance Property "RunAsUser" EksContainerSecurityContextProperty where + type PropertyType "RunAsUser" EksContainerSecurityContextProperty = Value Prelude.Integer + set newValue EksContainerSecurityContextProperty {..} + = EksContainerSecurityContextProperty + {runAsUser = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerSecurityContextProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksContainerSecurityContextProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerSecurityContextProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksContainerSecurityContextProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksContainerSecurityContextProperty :: Prelude.Type +instance ToResourceProperties EksContainerSecurityContextProperty +instance Prelude.Eq EksContainerSecurityContextProperty +instance Prelude.Show EksContainerSecurityContextProperty +instance JSON.ToJSON EksContainerSecurityContextProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerVolumeMountProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksContainerVolumeMountProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerVolumeMountProperty.hs @@ -0,0 +1,68 @@ +module Stratosphere.Batch.JobDefinition.EksContainerVolumeMountProperty ( + EksContainerVolumeMountProperty(..), + mkEksContainerVolumeMountProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksContainerVolumeMountProperty + = -- | See: + EksContainerVolumeMountProperty {haddock_workaround_ :: (), + -- | See: + mountPath :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + readOnly :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + subPath :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksContainerVolumeMountProperty :: + EksContainerVolumeMountProperty +mkEksContainerVolumeMountProperty + = EksContainerVolumeMountProperty + {haddock_workaround_ = (), mountPath = Prelude.Nothing, + name = Prelude.Nothing, readOnly = Prelude.Nothing, + subPath = Prelude.Nothing} +instance ToResourceProperties EksContainerVolumeMountProperty where + toResourceProperties EksContainerVolumeMountProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksContainerVolumeMount", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "MountPath" Prelude.<$> mountPath, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "ReadOnly" Prelude.<$> readOnly, + (JSON..=) "SubPath" Prelude.<$> subPath])} +instance JSON.ToJSON EksContainerVolumeMountProperty where + toJSON EksContainerVolumeMountProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "MountPath" Prelude.<$> mountPath, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "ReadOnly" Prelude.<$> readOnly, + (JSON..=) "SubPath" Prelude.<$> subPath])) +instance Property "MountPath" EksContainerVolumeMountProperty where + type PropertyType "MountPath" EksContainerVolumeMountProperty = Value Prelude.Text + set newValue EksContainerVolumeMountProperty {..} + = EksContainerVolumeMountProperty + {mountPath = Prelude.pure newValue, ..} +instance Property "Name" EksContainerVolumeMountProperty where + type PropertyType "Name" EksContainerVolumeMountProperty = Value Prelude.Text + set newValue EksContainerVolumeMountProperty {..} + = EksContainerVolumeMountProperty + {name = Prelude.pure newValue, ..} +instance Property "ReadOnly" EksContainerVolumeMountProperty where + type PropertyType "ReadOnly" EksContainerVolumeMountProperty = Value Prelude.Bool + set newValue EksContainerVolumeMountProperty {..} + = EksContainerVolumeMountProperty + {readOnly = Prelude.pure newValue, ..} +instance Property "SubPath" EksContainerVolumeMountProperty where + type PropertyType "SubPath" EksContainerVolumeMountProperty = Value Prelude.Text + set newValue EksContainerVolumeMountProperty {..} + = EksContainerVolumeMountProperty + {subPath = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksContainerVolumeMountProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksContainerVolumeMountProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksContainerVolumeMountProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksContainerVolumeMountProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksContainerVolumeMountProperty :: Prelude.Type +instance ToResourceProperties EksContainerVolumeMountProperty +instance Prelude.Eq EksContainerVolumeMountProperty +instance Prelude.Show EksContainerVolumeMountProperty +instance JSON.ToJSON EksContainerVolumeMountProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksEmptyDirProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksEmptyDirProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksEmptyDirProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobDefinition.EksEmptyDirProperty ( + EksEmptyDirProperty(..), mkEksEmptyDirProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksEmptyDirProperty + = -- | See: + EksEmptyDirProperty {haddock_workaround_ :: (), + -- | See: + medium :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + sizeLimit :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksEmptyDirProperty :: EksEmptyDirProperty +mkEksEmptyDirProperty + = EksEmptyDirProperty + {haddock_workaround_ = (), medium = Prelude.Nothing, + sizeLimit = Prelude.Nothing} +instance ToResourceProperties EksEmptyDirProperty where + toResourceProperties EksEmptyDirProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksEmptyDir", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Medium" Prelude.<$> medium, + (JSON..=) "SizeLimit" Prelude.<$> sizeLimit])} +instance JSON.ToJSON EksEmptyDirProperty where + toJSON EksEmptyDirProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Medium" Prelude.<$> medium, + (JSON..=) "SizeLimit" Prelude.<$> sizeLimit])) +instance Property "Medium" EksEmptyDirProperty where + type PropertyType "Medium" EksEmptyDirProperty = Value Prelude.Text + set newValue EksEmptyDirProperty {..} + = EksEmptyDirProperty {medium = Prelude.pure newValue, ..} +instance Property "SizeLimit" EksEmptyDirProperty where + type PropertyType "SizeLimit" EksEmptyDirProperty = Value Prelude.Text + set newValue EksEmptyDirProperty {..} + = EksEmptyDirProperty {sizeLimit = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksEmptyDirProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksEmptyDirProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksEmptyDirProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksEmptyDirProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksEmptyDirProperty :: Prelude.Type +instance ToResourceProperties EksEmptyDirProperty +instance Prelude.Eq EksEmptyDirProperty +instance Prelude.Show EksEmptyDirProperty +instance JSON.ToJSON EksEmptyDirProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksHostPathProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksHostPathProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksHostPathProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.Batch.JobDefinition.EksHostPathProperty ( + EksHostPathProperty(..), mkEksHostPathProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksHostPathProperty + = -- | See: + EksHostPathProperty {haddock_workaround_ :: (), + -- | See: + path :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksHostPathProperty :: EksHostPathProperty +mkEksHostPathProperty + = EksHostPathProperty + {haddock_workaround_ = (), path = Prelude.Nothing} +instance ToResourceProperties EksHostPathProperty where + toResourceProperties EksHostPathProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksHostPath", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Path" Prelude.<$> path])} +instance JSON.ToJSON EksHostPathProperty where + toJSON EksHostPathProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Path" Prelude.<$> path])) +instance Property "Path" EksHostPathProperty where + type PropertyType "Path" EksHostPathProperty = Value Prelude.Text + set newValue EksHostPathProperty {..} + = EksHostPathProperty {path = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksHostPathProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksHostPathProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksHostPathProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksHostPathProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksHostPathProperty :: Prelude.Type +instance ToResourceProperties EksHostPathProperty +instance Prelude.Eq EksHostPathProperty +instance Prelude.Show EksHostPathProperty +instance JSON.ToJSON EksHostPathProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksMetadataProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksMetadataProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksMetadataProperty.hs @@ -0,0 +1,53 @@ +module Stratosphere.Batch.JobDefinition.EksMetadataProperty ( + EksMetadataProperty(..), mkEksMetadataProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksMetadataProperty + = -- | See: + EksMetadataProperty {haddock_workaround_ :: (), + -- | See: + annotations :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + labels :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + namespace :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksMetadataProperty :: EksMetadataProperty +mkEksMetadataProperty + = EksMetadataProperty + {haddock_workaround_ = (), annotations = Prelude.Nothing, + labels = Prelude.Nothing, namespace = Prelude.Nothing} +instance ToResourceProperties EksMetadataProperty where + toResourceProperties EksMetadataProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksMetadata", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Annotations" Prelude.<$> annotations, + (JSON..=) "Labels" Prelude.<$> labels, + (JSON..=) "Namespace" Prelude.<$> namespace])} +instance JSON.ToJSON EksMetadataProperty where + toJSON EksMetadataProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Annotations" Prelude.<$> annotations, + (JSON..=) "Labels" Prelude.<$> labels, + (JSON..=) "Namespace" Prelude.<$> namespace])) +instance Property "Annotations" EksMetadataProperty where + type PropertyType "Annotations" EksMetadataProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue EksMetadataProperty {..} + = EksMetadataProperty {annotations = Prelude.pure newValue, ..} +instance Property "Labels" EksMetadataProperty where + type PropertyType "Labels" EksMetadataProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue EksMetadataProperty {..} + = EksMetadataProperty {labels = Prelude.pure newValue, ..} +instance Property "Namespace" EksMetadataProperty where + type PropertyType "Namespace" EksMetadataProperty = Value Prelude.Text + set newValue EksMetadataProperty {..} + = EksMetadataProperty {namespace = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksMetadataProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksMetadataProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksMetadataProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksMetadataProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksMetadataProperty :: Prelude.Type +instance ToResourceProperties EksMetadataProperty +instance Prelude.Eq EksMetadataProperty +instance Prelude.Show EksMetadataProperty +instance JSON.ToJSON EksMetadataProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksPersistentVolumeClaimProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksPersistentVolumeClaimProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksPersistentVolumeClaimProperty.hs @@ -0,0 +1,48 @@ +module Stratosphere.Batch.JobDefinition.EksPersistentVolumeClaimProperty ( + EksPersistentVolumeClaimProperty(..), + mkEksPersistentVolumeClaimProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksPersistentVolumeClaimProperty + = -- | See: + EksPersistentVolumeClaimProperty {haddock_workaround_ :: (), + -- | See: + claimName :: (Value Prelude.Text), + -- | See: + readOnly :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksPersistentVolumeClaimProperty :: + Value Prelude.Text -> EksPersistentVolumeClaimProperty +mkEksPersistentVolumeClaimProperty claimName + = EksPersistentVolumeClaimProperty + {haddock_workaround_ = (), claimName = claimName, + readOnly = Prelude.Nothing} +instance ToResourceProperties EksPersistentVolumeClaimProperty where + toResourceProperties EksPersistentVolumeClaimProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksPersistentVolumeClaim", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ClaimName" JSON..= claimName] + (Prelude.catMaybes [(JSON..=) "ReadOnly" Prelude.<$> readOnly]))} +instance JSON.ToJSON EksPersistentVolumeClaimProperty where + toJSON EksPersistentVolumeClaimProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClaimName" JSON..= claimName] + (Prelude.catMaybes [(JSON..=) "ReadOnly" Prelude.<$> readOnly]))) +instance Property "ClaimName" EksPersistentVolumeClaimProperty where + type PropertyType "ClaimName" EksPersistentVolumeClaimProperty = Value Prelude.Text + set newValue EksPersistentVolumeClaimProperty {..} + = EksPersistentVolumeClaimProperty {claimName = newValue, ..} +instance Property "ReadOnly" EksPersistentVolumeClaimProperty where + type PropertyType "ReadOnly" EksPersistentVolumeClaimProperty = Value Prelude.Bool + set newValue EksPersistentVolumeClaimProperty {..} + = EksPersistentVolumeClaimProperty + {readOnly = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksPersistentVolumeClaimProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksPersistentVolumeClaimProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksPersistentVolumeClaimProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksPersistentVolumeClaimProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksPersistentVolumeClaimProperty :: Prelude.Type +instance ToResourceProperties EksPersistentVolumeClaimProperty +instance Prelude.Eq EksPersistentVolumeClaimProperty +instance Prelude.Show EksPersistentVolumeClaimProperty +instance JSON.ToJSON EksPersistentVolumeClaimProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksPodPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksPodPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksPodPropertiesProperty.hs @@ -0,0 +1,117 @@ +module Stratosphere.Batch.JobDefinition.EksPodPropertiesProperty ( + module Exports, EksPodPropertiesProperty(..), + mkEksPodPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksContainerProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksMetadataProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksVolumeProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ImagePullSecretProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksPodPropertiesProperty + = -- | See: + EksPodPropertiesProperty {haddock_workaround_ :: (), + -- | See: + containers :: (Prelude.Maybe [EksContainerProperty]), + -- | See: + dnsPolicy :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + hostNetwork :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + imagePullSecrets :: (Prelude.Maybe [ImagePullSecretProperty]), + -- | See: + initContainers :: (Prelude.Maybe [EksContainerProperty]), + -- | See: + metadata :: (Prelude.Maybe EksMetadataProperty), + -- | See: + serviceAccountName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + shareProcessNamespace :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + volumes :: (Prelude.Maybe [EksVolumeProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksPodPropertiesProperty :: EksPodPropertiesProperty +mkEksPodPropertiesProperty + = EksPodPropertiesProperty + {haddock_workaround_ = (), containers = Prelude.Nothing, + dnsPolicy = Prelude.Nothing, hostNetwork = Prelude.Nothing, + imagePullSecrets = Prelude.Nothing, + initContainers = Prelude.Nothing, metadata = Prelude.Nothing, + serviceAccountName = Prelude.Nothing, + shareProcessNamespace = Prelude.Nothing, volumes = Prelude.Nothing} +instance ToResourceProperties EksPodPropertiesProperty where + toResourceProperties EksPodPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksPodProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Containers" Prelude.<$> containers, + (JSON..=) "DnsPolicy" Prelude.<$> dnsPolicy, + (JSON..=) "HostNetwork" Prelude.<$> hostNetwork, + (JSON..=) "ImagePullSecrets" Prelude.<$> imagePullSecrets, + (JSON..=) "InitContainers" Prelude.<$> initContainers, + (JSON..=) "Metadata" Prelude.<$> metadata, + (JSON..=) "ServiceAccountName" Prelude.<$> serviceAccountName, + (JSON..=) "ShareProcessNamespace" + Prelude.<$> shareProcessNamespace, + (JSON..=) "Volumes" Prelude.<$> volumes])} +instance JSON.ToJSON EksPodPropertiesProperty where + toJSON EksPodPropertiesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Containers" Prelude.<$> containers, + (JSON..=) "DnsPolicy" Prelude.<$> dnsPolicy, + (JSON..=) "HostNetwork" Prelude.<$> hostNetwork, + (JSON..=) "ImagePullSecrets" Prelude.<$> imagePullSecrets, + (JSON..=) "InitContainers" Prelude.<$> initContainers, + (JSON..=) "Metadata" Prelude.<$> metadata, + (JSON..=) "ServiceAccountName" Prelude.<$> serviceAccountName, + (JSON..=) "ShareProcessNamespace" + Prelude.<$> shareProcessNamespace, + (JSON..=) "Volumes" Prelude.<$> volumes])) +instance Property "Containers" EksPodPropertiesProperty where + type PropertyType "Containers" EksPodPropertiesProperty = [EksContainerProperty] + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty {containers = Prelude.pure newValue, ..} +instance Property "DnsPolicy" EksPodPropertiesProperty where + type PropertyType "DnsPolicy" EksPodPropertiesProperty = Value Prelude.Text + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty {dnsPolicy = Prelude.pure newValue, ..} +instance Property "HostNetwork" EksPodPropertiesProperty where + type PropertyType "HostNetwork" EksPodPropertiesProperty = Value Prelude.Bool + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty + {hostNetwork = Prelude.pure newValue, ..} +instance Property "ImagePullSecrets" EksPodPropertiesProperty where + type PropertyType "ImagePullSecrets" EksPodPropertiesProperty = [ImagePullSecretProperty] + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty + {imagePullSecrets = Prelude.pure newValue, ..} +instance Property "InitContainers" EksPodPropertiesProperty where + type PropertyType "InitContainers" EksPodPropertiesProperty = [EksContainerProperty] + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty + {initContainers = Prelude.pure newValue, ..} +instance Property "Metadata" EksPodPropertiesProperty where + type PropertyType "Metadata" EksPodPropertiesProperty = EksMetadataProperty + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty {metadata = Prelude.pure newValue, ..} +instance Property "ServiceAccountName" EksPodPropertiesProperty where + type PropertyType "ServiceAccountName" EksPodPropertiesProperty = Value Prelude.Text + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty + {serviceAccountName = Prelude.pure newValue, ..} +instance Property "ShareProcessNamespace" EksPodPropertiesProperty where + type PropertyType "ShareProcessNamespace" EksPodPropertiesProperty = Value Prelude.Bool + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty + {shareProcessNamespace = Prelude.pure newValue, ..} +instance Property "Volumes" EksPodPropertiesProperty where + type PropertyType "Volumes" EksPodPropertiesProperty = [EksVolumeProperty] + set newValue EksPodPropertiesProperty {..} + = EksPodPropertiesProperty {volumes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksPodPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksPodPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksPodPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksPodPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksPodPropertiesProperty :: Prelude.Type +instance ToResourceProperties EksPodPropertiesProperty +instance Prelude.Eq EksPodPropertiesProperty +instance Prelude.Show EksPodPropertiesProperty +instance JSON.ToJSON EksPodPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksPropertiesProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.Batch.JobDefinition.EksPropertiesProperty ( + module Exports, EksPropertiesProperty(..), mkEksPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksPodPropertiesProperty as Exports +import Stratosphere.ResourceProperties +data EksPropertiesProperty + = -- | See: + EksPropertiesProperty {haddock_workaround_ :: (), + -- | See: + podProperties :: (Prelude.Maybe EksPodPropertiesProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksPropertiesProperty :: EksPropertiesProperty +mkEksPropertiesProperty + = EksPropertiesProperty + {haddock_workaround_ = (), podProperties = Prelude.Nothing} +instance ToResourceProperties EksPropertiesProperty where + toResourceProperties EksPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "PodProperties" Prelude.<$> podProperties])} +instance JSON.ToJSON EksPropertiesProperty where + toJSON EksPropertiesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "PodProperties" Prelude.<$> podProperties])) +instance Property "PodProperties" EksPropertiesProperty where + type PropertyType "PodProperties" EksPropertiesProperty = EksPodPropertiesProperty + set newValue EksPropertiesProperty {..} + = EksPropertiesProperty {podProperties = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksPropertiesProperty :: Prelude.Type +instance ToResourceProperties EksPropertiesProperty +instance Prelude.Eq EksPropertiesProperty +instance Prelude.Show EksPropertiesProperty +instance JSON.ToJSON EksPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksSecretProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksSecretProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksSecretProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobDefinition.EksSecretProperty ( + EksSecretProperty(..), mkEksSecretProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksSecretProperty + = -- | See: + EksSecretProperty {haddock_workaround_ :: (), + -- | See: + optional :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + secretName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksSecretProperty :: Value Prelude.Text -> EksSecretProperty +mkEksSecretProperty secretName + = EksSecretProperty + {haddock_workaround_ = (), secretName = secretName, + optional = Prelude.Nothing} +instance ToResourceProperties EksSecretProperty where + toResourceProperties EksSecretProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksSecret", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["SecretName" JSON..= secretName] + (Prelude.catMaybes [(JSON..=) "Optional" Prelude.<$> optional]))} +instance JSON.ToJSON EksSecretProperty where + toJSON EksSecretProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["SecretName" JSON..= secretName] + (Prelude.catMaybes [(JSON..=) "Optional" Prelude.<$> optional]))) +instance Property "Optional" EksSecretProperty where + type PropertyType "Optional" EksSecretProperty = Value Prelude.Bool + set newValue EksSecretProperty {..} + = EksSecretProperty {optional = Prelude.pure newValue, ..} +instance Property "SecretName" EksSecretProperty where + type PropertyType "SecretName" EksSecretProperty = Value Prelude.Text + set newValue EksSecretProperty {..} + = EksSecretProperty {secretName = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksSecretProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksSecretProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksSecretProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksSecretProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksSecretProperty :: Prelude.Type +instance ToResourceProperties EksSecretProperty +instance Prelude.Eq EksSecretProperty +instance Prelude.Show EksSecretProperty +instance JSON.ToJSON EksSecretProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EksVolumeProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EksVolumeProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksVolumeProperty.hs @@ -0,0 +1,79 @@ +module Stratosphere.Batch.JobDefinition.EksVolumeProperty ( + module Exports, EksVolumeProperty(..), mkEksVolumeProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksEmptyDirProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksHostPathProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksPersistentVolumeClaimProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksSecretProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksVolumeProperty + = -- | See: + EksVolumeProperty {haddock_workaround_ :: (), + -- | See: + emptyDir :: (Prelude.Maybe EksEmptyDirProperty), + -- | See: + hostPath :: (Prelude.Maybe EksHostPathProperty), + -- | See: + name :: (Value Prelude.Text), + -- | See: + persistentVolumeClaim :: (Prelude.Maybe EksPersistentVolumeClaimProperty), + -- | See: + secret :: (Prelude.Maybe EksSecretProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksVolumeProperty :: Value Prelude.Text -> EksVolumeProperty +mkEksVolumeProperty name + = EksVolumeProperty + {haddock_workaround_ = (), name = name, emptyDir = Prelude.Nothing, + hostPath = Prelude.Nothing, + persistentVolumeClaim = Prelude.Nothing, secret = Prelude.Nothing} +instance ToResourceProperties EksVolumeProperty where + toResourceProperties EksVolumeProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EksVolume", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Name" JSON..= name] + (Prelude.catMaybes + [(JSON..=) "EmptyDir" Prelude.<$> emptyDir, + (JSON..=) "HostPath" Prelude.<$> hostPath, + (JSON..=) "PersistentVolumeClaim" + Prelude.<$> persistentVolumeClaim, + (JSON..=) "Secret" Prelude.<$> secret]))} +instance JSON.ToJSON EksVolumeProperty where + toJSON EksVolumeProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Name" JSON..= name] + (Prelude.catMaybes + [(JSON..=) "EmptyDir" Prelude.<$> emptyDir, + (JSON..=) "HostPath" Prelude.<$> hostPath, + (JSON..=) "PersistentVolumeClaim" + Prelude.<$> persistentVolumeClaim, + (JSON..=) "Secret" Prelude.<$> secret]))) +instance Property "EmptyDir" EksVolumeProperty where + type PropertyType "EmptyDir" EksVolumeProperty = EksEmptyDirProperty + set newValue EksVolumeProperty {..} + = EksVolumeProperty {emptyDir = Prelude.pure newValue, ..} +instance Property "HostPath" EksVolumeProperty where + type PropertyType "HostPath" EksVolumeProperty = EksHostPathProperty + set newValue EksVolumeProperty {..} + = EksVolumeProperty {hostPath = Prelude.pure newValue, ..} +instance Property "Name" EksVolumeProperty where + type PropertyType "Name" EksVolumeProperty = Value Prelude.Text + set newValue EksVolumeProperty {..} + = EksVolumeProperty {name = newValue, ..} +instance Property "PersistentVolumeClaim" EksVolumeProperty where + type PropertyType "PersistentVolumeClaim" EksVolumeProperty = EksPersistentVolumeClaimProperty + set newValue EksVolumeProperty {..} + = EksVolumeProperty + {persistentVolumeClaim = Prelude.pure newValue, ..} +instance Property "Secret" EksVolumeProperty where + type PropertyType "Secret" EksVolumeProperty = EksSecretProperty + set newValue EksVolumeProperty {..} + = EksVolumeProperty {secret = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EksVolumeProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EksVolumeProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EksVolumeProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EksVolumeProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksVolumeProperty :: Prelude.Type +instance ToResourceProperties EksVolumeProperty +instance Prelude.Eq EksVolumeProperty +instance Prelude.Show EksVolumeProperty +instance JSON.ToJSON EksVolumeProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EnvironmentProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EnvironmentProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EnvironmentProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobDefinition.EnvironmentProperty ( + EnvironmentProperty(..), mkEnvironmentProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EnvironmentProperty + = -- | See: + EnvironmentProperty {haddock_workaround_ :: (), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + value :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEnvironmentProperty :: EnvironmentProperty +mkEnvironmentProperty + = EnvironmentProperty + {haddock_workaround_ = (), name = Prelude.Nothing, + value = Prelude.Nothing} +instance ToResourceProperties EnvironmentProperty where + toResourceProperties EnvironmentProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Environment", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Value" Prelude.<$> value])} +instance JSON.ToJSON EnvironmentProperty where + toJSON EnvironmentProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Value" Prelude.<$> value])) +instance Property "Name" EnvironmentProperty where + type PropertyType "Name" EnvironmentProperty = Value Prelude.Text + set newValue EnvironmentProperty {..} + = EnvironmentProperty {name = Prelude.pure newValue, ..} +instance Property "Value" EnvironmentProperty where + type PropertyType "Value" EnvironmentProperty = Value Prelude.Text + set newValue EnvironmentProperty {..} + = EnvironmentProperty {value = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EnvironmentProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EnvironmentProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EnvironmentProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EnvironmentProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EnvironmentProperty :: Prelude.Type +instance ToResourceProperties EnvironmentProperty +instance Prelude.Eq EnvironmentProperty +instance Prelude.Show EnvironmentProperty +instance JSON.ToJSON EnvironmentProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EphemeralStorageProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EphemeralStorageProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EphemeralStorageProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.Batch.JobDefinition.EphemeralStorageProperty ( + EphemeralStorageProperty(..), mkEphemeralStorageProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EphemeralStorageProperty + = -- | See: + EphemeralStorageProperty {haddock_workaround_ :: (), + -- | See: + sizeInGiB :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEphemeralStorageProperty :: + Value Prelude.Integer -> EphemeralStorageProperty +mkEphemeralStorageProperty sizeInGiB + = EphemeralStorageProperty + {haddock_workaround_ = (), sizeInGiB = sizeInGiB} +instance ToResourceProperties EphemeralStorageProperty where + toResourceProperties EphemeralStorageProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EphemeralStorage", + supportsTags = Prelude.False, + properties = ["SizeInGiB" JSON..= sizeInGiB]} +instance JSON.ToJSON EphemeralStorageProperty where + toJSON EphemeralStorageProperty {..} + = JSON.object ["SizeInGiB" JSON..= sizeInGiB] +instance Property "SizeInGiB" EphemeralStorageProperty where + type PropertyType "SizeInGiB" EphemeralStorageProperty = Value Prelude.Integer + set newValue EphemeralStorageProperty {..} + = EphemeralStorageProperty {sizeInGiB = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EphemeralStorageProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EphemeralStorageProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EphemeralStorageProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EphemeralStorageProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EphemeralStorageProperty :: Prelude.Type +instance ToResourceProperties EphemeralStorageProperty +instance Prelude.Eq EphemeralStorageProperty +instance Prelude.Show EphemeralStorageProperty +instance JSON.ToJSON EphemeralStorageProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/EvaluateOnExitProperty.hs b/gen/Stratosphere/Batch/JobDefinition/EvaluateOnExitProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EvaluateOnExitProperty.hs @@ -0,0 +1,66 @@ +module Stratosphere.Batch.JobDefinition.EvaluateOnExitProperty ( + EvaluateOnExitProperty(..), mkEvaluateOnExitProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EvaluateOnExitProperty + = -- | See: + EvaluateOnExitProperty {haddock_workaround_ :: (), + -- | See: + action :: (Value Prelude.Text), + -- | See: + onExitCode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + onReason :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + onStatusReason :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEvaluateOnExitProperty :: + Value Prelude.Text -> EvaluateOnExitProperty +mkEvaluateOnExitProperty action + = EvaluateOnExitProperty + {haddock_workaround_ = (), action = action, + onExitCode = Prelude.Nothing, onReason = Prelude.Nothing, + onStatusReason = Prelude.Nothing} +instance ToResourceProperties EvaluateOnExitProperty where + toResourceProperties EvaluateOnExitProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.EvaluateOnExit", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Action" JSON..= action] + (Prelude.catMaybes + [(JSON..=) "OnExitCode" Prelude.<$> onExitCode, + (JSON..=) "OnReason" Prelude.<$> onReason, + (JSON..=) "OnStatusReason" Prelude.<$> onStatusReason]))} +instance JSON.ToJSON EvaluateOnExitProperty where + toJSON EvaluateOnExitProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Action" JSON..= action] + (Prelude.catMaybes + [(JSON..=) "OnExitCode" Prelude.<$> onExitCode, + (JSON..=) "OnReason" Prelude.<$> onReason, + (JSON..=) "OnStatusReason" Prelude.<$> onStatusReason]))) +instance Property "Action" EvaluateOnExitProperty where + type PropertyType "Action" EvaluateOnExitProperty = Value Prelude.Text + set newValue EvaluateOnExitProperty {..} + = EvaluateOnExitProperty {action = newValue, ..} +instance Property "OnExitCode" EvaluateOnExitProperty where + type PropertyType "OnExitCode" EvaluateOnExitProperty = Value Prelude.Text + set newValue EvaluateOnExitProperty {..} + = EvaluateOnExitProperty {onExitCode = Prelude.pure newValue, ..} +instance Property "OnReason" EvaluateOnExitProperty where + type PropertyType "OnReason" EvaluateOnExitProperty = Value Prelude.Text + set newValue EvaluateOnExitProperty {..} + = EvaluateOnExitProperty {onReason = Prelude.pure newValue, ..} +instance Property "OnStatusReason" EvaluateOnExitProperty where + type PropertyType "OnStatusReason" EvaluateOnExitProperty = Value Prelude.Text + set newValue EvaluateOnExitProperty {..} + = EvaluateOnExitProperty + {onStatusReason = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/EvaluateOnExitProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/EvaluateOnExitProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/EvaluateOnExitProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.EvaluateOnExitProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EvaluateOnExitProperty :: Prelude.Type +instance ToResourceProperties EvaluateOnExitProperty +instance Prelude.Eq EvaluateOnExitProperty +instance Prelude.Show EvaluateOnExitProperty +instance JSON.ToJSON EvaluateOnExitProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/FargatePlatformConfigurationProperty.hs b/gen/Stratosphere/Batch/JobDefinition/FargatePlatformConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/FargatePlatformConfigurationProperty.hs @@ -0,0 +1,39 @@ +module Stratosphere.Batch.JobDefinition.FargatePlatformConfigurationProperty ( + FargatePlatformConfigurationProperty(..), + mkFargatePlatformConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data FargatePlatformConfigurationProperty + = -- | See: + FargatePlatformConfigurationProperty {haddock_workaround_ :: (), + -- | See: + platformVersion :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkFargatePlatformConfigurationProperty :: + FargatePlatformConfigurationProperty +mkFargatePlatformConfigurationProperty + = FargatePlatformConfigurationProperty + {haddock_workaround_ = (), platformVersion = Prelude.Nothing} +instance ToResourceProperties FargatePlatformConfigurationProperty where + toResourceProperties FargatePlatformConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.FargatePlatformConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "PlatformVersion" Prelude.<$> platformVersion])} +instance JSON.ToJSON FargatePlatformConfigurationProperty where + toJSON FargatePlatformConfigurationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "PlatformVersion" Prelude.<$> platformVersion])) +instance Property "PlatformVersion" FargatePlatformConfigurationProperty where + type PropertyType "PlatformVersion" FargatePlatformConfigurationProperty = Value Prelude.Text + set newValue FargatePlatformConfigurationProperty {..} + = FargatePlatformConfigurationProperty + {platformVersion = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/FargatePlatformConfigurationProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/FargatePlatformConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/FargatePlatformConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.FargatePlatformConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data FargatePlatformConfigurationProperty :: Prelude.Type +instance ToResourceProperties FargatePlatformConfigurationProperty +instance Prelude.Eq FargatePlatformConfigurationProperty +instance Prelude.Show FargatePlatformConfigurationProperty +instance JSON.ToJSON FargatePlatformConfigurationProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/FirelensConfigurationProperty.hs b/gen/Stratosphere/Batch/JobDefinition/FirelensConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/FirelensConfigurationProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.Batch.JobDefinition.FirelensConfigurationProperty ( + FirelensConfigurationProperty(..), mkFirelensConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data FirelensConfigurationProperty + = -- | See: + FirelensConfigurationProperty {haddock_workaround_ :: (), + -- | See: + options :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + type' :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkFirelensConfigurationProperty :: + Value Prelude.Text -> FirelensConfigurationProperty +mkFirelensConfigurationProperty type' + = FirelensConfigurationProperty + {haddock_workaround_ = (), type' = type', + options = Prelude.Nothing} +instance ToResourceProperties FirelensConfigurationProperty where + toResourceProperties FirelensConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.FirelensConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes [(JSON..=) "Options" Prelude.<$> options]))} +instance JSON.ToJSON FirelensConfigurationProperty where + toJSON FirelensConfigurationProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes [(JSON..=) "Options" Prelude.<$> options]))) +instance Property "Options" FirelensConfigurationProperty where + type PropertyType "Options" FirelensConfigurationProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue FirelensConfigurationProperty {..} + = FirelensConfigurationProperty + {options = Prelude.pure newValue, ..} +instance Property "Type" FirelensConfigurationProperty where + type PropertyType "Type" FirelensConfigurationProperty = Value Prelude.Text + set newValue FirelensConfigurationProperty {..} + = FirelensConfigurationProperty {type' = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/FirelensConfigurationProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/FirelensConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/FirelensConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.FirelensConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data FirelensConfigurationProperty :: Prelude.Type +instance ToResourceProperties FirelensConfigurationProperty +instance Prelude.Eq FirelensConfigurationProperty +instance Prelude.Show FirelensConfigurationProperty +instance JSON.ToJSON FirelensConfigurationProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/HostProperty.hs b/gen/Stratosphere/Batch/JobDefinition/HostProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/HostProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.Batch.JobDefinition.HostProperty ( + HostProperty(..), mkHostProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HostProperty + = -- | See: + HostProperty {haddock_workaround_ :: (), + -- | See: + sourcePath :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkHostProperty :: HostProperty +mkHostProperty + = HostProperty + {haddock_workaround_ = (), sourcePath = Prelude.Nothing} +instance ToResourceProperties HostProperty where + toResourceProperties HostProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Host", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SourcePath" Prelude.<$> sourcePath])} +instance JSON.ToJSON HostProperty where + toJSON HostProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SourcePath" Prelude.<$> sourcePath])) +instance Property "SourcePath" HostProperty where + type PropertyType "SourcePath" HostProperty = Value Prelude.Text + set newValue HostProperty {..} + = HostProperty {sourcePath = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/HostProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/HostProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/HostProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.HostProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data HostProperty :: Prelude.Type +instance ToResourceProperties HostProperty +instance Prelude.Eq HostProperty +instance Prelude.Show HostProperty +instance JSON.ToJSON HostProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/ImagePullSecretProperty.hs b/gen/Stratosphere/Batch/JobDefinition/ImagePullSecretProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ImagePullSecretProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.Batch.JobDefinition.ImagePullSecretProperty ( + ImagePullSecretProperty(..), mkImagePullSecretProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ImagePullSecretProperty + = -- | See: + ImagePullSecretProperty {haddock_workaround_ :: (), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkImagePullSecretProperty :: ImagePullSecretProperty +mkImagePullSecretProperty + = ImagePullSecretProperty + {haddock_workaround_ = (), name = Prelude.Nothing} +instance ToResourceProperties ImagePullSecretProperty where + toResourceProperties ImagePullSecretProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.ImagePullSecret", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Name" Prelude.<$> name])} +instance JSON.ToJSON ImagePullSecretProperty where + toJSON ImagePullSecretProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Name" Prelude.<$> name])) +instance Property "Name" ImagePullSecretProperty where + type PropertyType "Name" ImagePullSecretProperty = Value Prelude.Text + set newValue ImagePullSecretProperty {..} + = ImagePullSecretProperty {name = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ImagePullSecretProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/ImagePullSecretProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ImagePullSecretProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.ImagePullSecretProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ImagePullSecretProperty :: Prelude.Type +instance ToResourceProperties ImagePullSecretProperty +instance Prelude.Eq ImagePullSecretProperty +instance Prelude.Show ImagePullSecretProperty +instance JSON.ToJSON ImagePullSecretProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/JobTimeoutProperty.hs b/gen/Stratosphere/Batch/JobDefinition/JobTimeoutProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/JobTimeoutProperty.hs @@ -0,0 +1,40 @@ +module Stratosphere.Batch.JobDefinition.JobTimeoutProperty ( + JobTimeoutProperty(..), mkJobTimeoutProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data JobTimeoutProperty + = -- | See: + JobTimeoutProperty {haddock_workaround_ :: (), + -- | See: + attemptDurationSeconds :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkJobTimeoutProperty :: JobTimeoutProperty +mkJobTimeoutProperty + = JobTimeoutProperty + {haddock_workaround_ = (), + attemptDurationSeconds = Prelude.Nothing} +instance ToResourceProperties JobTimeoutProperty where + toResourceProperties JobTimeoutProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.JobTimeout", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AttemptDurationSeconds" + Prelude.<$> attemptDurationSeconds])} +instance JSON.ToJSON JobTimeoutProperty where + toJSON JobTimeoutProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AttemptDurationSeconds" + Prelude.<$> attemptDurationSeconds])) +instance Property "AttemptDurationSeconds" JobTimeoutProperty where + type PropertyType "AttemptDurationSeconds" JobTimeoutProperty = Value Prelude.Integer + set newValue JobTimeoutProperty {..} + = JobTimeoutProperty + {attemptDurationSeconds = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/JobTimeoutProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/JobTimeoutProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/JobTimeoutProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.JobTimeoutProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data JobTimeoutProperty :: Prelude.Type +instance ToResourceProperties JobTimeoutProperty +instance Prelude.Eq JobTimeoutProperty +instance Prelude.Show JobTimeoutProperty +instance JSON.ToJSON JobTimeoutProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/LinuxParametersProperty.hs b/gen/Stratosphere/Batch/JobDefinition/LinuxParametersProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/LinuxParametersProperty.hs @@ -0,0 +1,84 @@ +module Stratosphere.Batch.JobDefinition.LinuxParametersProperty ( + module Exports, LinuxParametersProperty(..), + mkLinuxParametersProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.DeviceProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.TmpfsProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LinuxParametersProperty + = -- | See: + LinuxParametersProperty {haddock_workaround_ :: (), + -- | See: + devices :: (Prelude.Maybe [DeviceProperty]), + -- | See: + initProcessEnabled :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + maxSwap :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + sharedMemorySize :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + swappiness :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + tmpfs :: (Prelude.Maybe [TmpfsProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkLinuxParametersProperty :: LinuxParametersProperty +mkLinuxParametersProperty + = LinuxParametersProperty + {haddock_workaround_ = (), devices = Prelude.Nothing, + initProcessEnabled = Prelude.Nothing, maxSwap = Prelude.Nothing, + sharedMemorySize = Prelude.Nothing, swappiness = Prelude.Nothing, + tmpfs = Prelude.Nothing} +instance ToResourceProperties LinuxParametersProperty where + toResourceProperties LinuxParametersProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.LinuxParameters", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Devices" Prelude.<$> devices, + (JSON..=) "InitProcessEnabled" Prelude.<$> initProcessEnabled, + (JSON..=) "MaxSwap" Prelude.<$> maxSwap, + (JSON..=) "SharedMemorySize" Prelude.<$> sharedMemorySize, + (JSON..=) "Swappiness" Prelude.<$> swappiness, + (JSON..=) "Tmpfs" Prelude.<$> tmpfs])} +instance JSON.ToJSON LinuxParametersProperty where + toJSON LinuxParametersProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Devices" Prelude.<$> devices, + (JSON..=) "InitProcessEnabled" Prelude.<$> initProcessEnabled, + (JSON..=) "MaxSwap" Prelude.<$> maxSwap, + (JSON..=) "SharedMemorySize" Prelude.<$> sharedMemorySize, + (JSON..=) "Swappiness" Prelude.<$> swappiness, + (JSON..=) "Tmpfs" Prelude.<$> tmpfs])) +instance Property "Devices" LinuxParametersProperty where + type PropertyType "Devices" LinuxParametersProperty = [DeviceProperty] + set newValue LinuxParametersProperty {..} + = LinuxParametersProperty {devices = Prelude.pure newValue, ..} +instance Property "InitProcessEnabled" LinuxParametersProperty where + type PropertyType "InitProcessEnabled" LinuxParametersProperty = Value Prelude.Bool + set newValue LinuxParametersProperty {..} + = LinuxParametersProperty + {initProcessEnabled = Prelude.pure newValue, ..} +instance Property "MaxSwap" LinuxParametersProperty where + type PropertyType "MaxSwap" LinuxParametersProperty = Value Prelude.Integer + set newValue LinuxParametersProperty {..} + = LinuxParametersProperty {maxSwap = Prelude.pure newValue, ..} +instance Property "SharedMemorySize" LinuxParametersProperty where + type PropertyType "SharedMemorySize" LinuxParametersProperty = Value Prelude.Integer + set newValue LinuxParametersProperty {..} + = LinuxParametersProperty + {sharedMemorySize = Prelude.pure newValue, ..} +instance Property "Swappiness" LinuxParametersProperty where + type PropertyType "Swappiness" LinuxParametersProperty = Value Prelude.Integer + set newValue LinuxParametersProperty {..} + = LinuxParametersProperty {swappiness = Prelude.pure newValue, ..} +instance Property "Tmpfs" LinuxParametersProperty where + type PropertyType "Tmpfs" LinuxParametersProperty = [TmpfsProperty] + set newValue LinuxParametersProperty {..} + = LinuxParametersProperty {tmpfs = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/LinuxParametersProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/LinuxParametersProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/LinuxParametersProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.LinuxParametersProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LinuxParametersProperty :: Prelude.Type +instance ToResourceProperties LinuxParametersProperty +instance Prelude.Eq LinuxParametersProperty +instance Prelude.Show LinuxParametersProperty +instance JSON.ToJSON LinuxParametersProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/LogConfigurationProperty.hs b/gen/Stratosphere/Batch/JobDefinition/LogConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/LogConfigurationProperty.hs @@ -0,0 +1,59 @@ +module Stratosphere.Batch.JobDefinition.LogConfigurationProperty ( + module Exports, LogConfigurationProperty(..), + mkLogConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.SecretProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LogConfigurationProperty + = -- | See: + LogConfigurationProperty {haddock_workaround_ :: (), + -- | See: + logDriver :: (Value Prelude.Text), + -- | See: + options :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + secretOptions :: (Prelude.Maybe [SecretProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkLogConfigurationProperty :: + Value Prelude.Text -> LogConfigurationProperty +mkLogConfigurationProperty logDriver + = LogConfigurationProperty + {haddock_workaround_ = (), logDriver = logDriver, + options = Prelude.Nothing, secretOptions = Prelude.Nothing} +instance ToResourceProperties LogConfigurationProperty where + toResourceProperties LogConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.LogConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["LogDriver" JSON..= logDriver] + (Prelude.catMaybes + [(JSON..=) "Options" Prelude.<$> options, + (JSON..=) "SecretOptions" Prelude.<$> secretOptions]))} +instance JSON.ToJSON LogConfigurationProperty where + toJSON LogConfigurationProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["LogDriver" JSON..= logDriver] + (Prelude.catMaybes + [(JSON..=) "Options" Prelude.<$> options, + (JSON..=) "SecretOptions" Prelude.<$> secretOptions]))) +instance Property "LogDriver" LogConfigurationProperty where + type PropertyType "LogDriver" LogConfigurationProperty = Value Prelude.Text + set newValue LogConfigurationProperty {..} + = LogConfigurationProperty {logDriver = newValue, ..} +instance Property "Options" LogConfigurationProperty where + type PropertyType "Options" LogConfigurationProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue LogConfigurationProperty {..} + = LogConfigurationProperty {options = Prelude.pure newValue, ..} +instance Property "SecretOptions" LogConfigurationProperty where + type PropertyType "SecretOptions" LogConfigurationProperty = [SecretProperty] + set newValue LogConfigurationProperty {..} + = LogConfigurationProperty + {secretOptions = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/LogConfigurationProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/LogConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/LogConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.LogConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LogConfigurationProperty :: Prelude.Type +instance ToResourceProperties LogConfigurationProperty +instance Prelude.Eq LogConfigurationProperty +instance Prelude.Show LogConfigurationProperty +instance JSON.ToJSON LogConfigurationProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/MountPointProperty.hs b/gen/Stratosphere/Batch/JobDefinition/MountPointProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MountPointProperty.hs @@ -0,0 +1,53 @@ +module Stratosphere.Batch.JobDefinition.MountPointProperty ( + MountPointProperty(..), mkMountPointProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data MountPointProperty + = -- | See: + MountPointProperty {haddock_workaround_ :: (), + -- | See: + containerPath :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + readOnly :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + sourceVolume :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkMountPointProperty :: MountPointProperty +mkMountPointProperty + = MountPointProperty + {haddock_workaround_ = (), containerPath = Prelude.Nothing, + readOnly = Prelude.Nothing, sourceVolume = Prelude.Nothing} +instance ToResourceProperties MountPointProperty where + toResourceProperties MountPointProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.MountPoint", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ContainerPath" Prelude.<$> containerPath, + (JSON..=) "ReadOnly" Prelude.<$> readOnly, + (JSON..=) "SourceVolume" Prelude.<$> sourceVolume])} +instance JSON.ToJSON MountPointProperty where + toJSON MountPointProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ContainerPath" Prelude.<$> containerPath, + (JSON..=) "ReadOnly" Prelude.<$> readOnly, + (JSON..=) "SourceVolume" Prelude.<$> sourceVolume])) +instance Property "ContainerPath" MountPointProperty where + type PropertyType "ContainerPath" MountPointProperty = Value Prelude.Text + set newValue MountPointProperty {..} + = MountPointProperty {containerPath = Prelude.pure newValue, ..} +instance Property "ReadOnly" MountPointProperty where + type PropertyType "ReadOnly" MountPointProperty = Value Prelude.Bool + set newValue MountPointProperty {..} + = MountPointProperty {readOnly = Prelude.pure newValue, ..} +instance Property "SourceVolume" MountPointProperty where + type PropertyType "SourceVolume" MountPointProperty = Value Prelude.Text + set newValue MountPointProperty {..} + = MountPointProperty {sourceVolume = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/MountPointProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/MountPointProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MountPointProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.MountPointProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data MountPointProperty :: Prelude.Type +instance ToResourceProperties MountPointProperty +instance Prelude.Eq MountPointProperty +instance Prelude.Show MountPointProperty +instance JSON.ToJSON MountPointProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/MultiNodeContainerPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/MultiNodeContainerPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MultiNodeContainerPropertiesProperty.hs @@ -0,0 +1,256 @@ +module Stratosphere.Batch.JobDefinition.MultiNodeContainerPropertiesProperty ( + module Exports, MultiNodeContainerPropertiesProperty(..), + mkMultiNodeContainerPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EnvironmentProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EphemeralStorageProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.LinuxParametersProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.LogConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.MountPointProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RepositoryCredentialsProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ResourceRequirementProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RuntimePlatformProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.SecretProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.UlimitProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.VolumeProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data MultiNodeContainerPropertiesProperty + = -- | See: + MultiNodeContainerPropertiesProperty {haddock_workaround_ :: (), + -- | See: + command :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + enableExecuteCommand :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + environment :: (Prelude.Maybe [EnvironmentProperty]), + -- | See: + ephemeralStorage :: (Prelude.Maybe EphemeralStorageProperty), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + image :: (Value Prelude.Text), + -- | See: + instanceType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + jobRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + linuxParameters :: (Prelude.Maybe LinuxParametersProperty), + -- | See: + logConfiguration :: (Prelude.Maybe LogConfigurationProperty), + -- | See: + memory :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + mountPoints :: (Prelude.Maybe [MountPointProperty]), + -- | See: + privileged :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + readonlyRootFilesystem :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + repositoryCredentials :: (Prelude.Maybe RepositoryCredentialsProperty), + -- | See: + resourceRequirements :: (Prelude.Maybe [ResourceRequirementProperty]), + -- | See: + runtimePlatform :: (Prelude.Maybe RuntimePlatformProperty), + -- | See: + secrets :: (Prelude.Maybe [SecretProperty]), + -- | See: + ulimits :: (Prelude.Maybe [UlimitProperty]), + -- | See: + user :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + vcpus :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + volumes :: (Prelude.Maybe [VolumeProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkMultiNodeContainerPropertiesProperty :: + Value Prelude.Text -> MultiNodeContainerPropertiesProperty +mkMultiNodeContainerPropertiesProperty image + = MultiNodeContainerPropertiesProperty + {haddock_workaround_ = (), image = image, + command = Prelude.Nothing, enableExecuteCommand = Prelude.Nothing, + environment = Prelude.Nothing, ephemeralStorage = Prelude.Nothing, + executionRoleArn = Prelude.Nothing, instanceType = Prelude.Nothing, + jobRoleArn = Prelude.Nothing, linuxParameters = Prelude.Nothing, + logConfiguration = Prelude.Nothing, memory = Prelude.Nothing, + mountPoints = Prelude.Nothing, privileged = Prelude.Nothing, + readonlyRootFilesystem = Prelude.Nothing, + repositoryCredentials = Prelude.Nothing, + resourceRequirements = Prelude.Nothing, + runtimePlatform = Prelude.Nothing, secrets = Prelude.Nothing, + ulimits = Prelude.Nothing, user = Prelude.Nothing, + vcpus = Prelude.Nothing, volumes = Prelude.Nothing} +instance ToResourceProperties MultiNodeContainerPropertiesProperty where + toResourceProperties MultiNodeContainerPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.MultiNodeContainerProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Command" Prelude.<$> command, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "Environment" Prelude.<$> environment, + (JSON..=) "EphemeralStorage" Prelude.<$> ephemeralStorage, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "InstanceType" Prelude.<$> instanceType, + (JSON..=) "JobRoleArn" Prelude.<$> jobRoleArn, + (JSON..=) "LinuxParameters" Prelude.<$> linuxParameters, + (JSON..=) "LogConfiguration" Prelude.<$> logConfiguration, + (JSON..=) "Memory" Prelude.<$> memory, + (JSON..=) "MountPoints" Prelude.<$> mountPoints, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadonlyRootFilesystem" + Prelude.<$> readonlyRootFilesystem, + (JSON..=) "RepositoryCredentials" + Prelude.<$> repositoryCredentials, + (JSON..=) "ResourceRequirements" Prelude.<$> resourceRequirements, + (JSON..=) "RuntimePlatform" Prelude.<$> runtimePlatform, + (JSON..=) "Secrets" Prelude.<$> secrets, + (JSON..=) "Ulimits" Prelude.<$> ulimits, + (JSON..=) "User" Prelude.<$> user, + (JSON..=) "Vcpus" Prelude.<$> vcpus, + (JSON..=) "Volumes" Prelude.<$> volumes]))} +instance JSON.ToJSON MultiNodeContainerPropertiesProperty where + toJSON MultiNodeContainerPropertiesProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Command" Prelude.<$> command, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "Environment" Prelude.<$> environment, + (JSON..=) "EphemeralStorage" Prelude.<$> ephemeralStorage, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "InstanceType" Prelude.<$> instanceType, + (JSON..=) "JobRoleArn" Prelude.<$> jobRoleArn, + (JSON..=) "LinuxParameters" Prelude.<$> linuxParameters, + (JSON..=) "LogConfiguration" Prelude.<$> logConfiguration, + (JSON..=) "Memory" Prelude.<$> memory, + (JSON..=) "MountPoints" Prelude.<$> mountPoints, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadonlyRootFilesystem" + Prelude.<$> readonlyRootFilesystem, + (JSON..=) "RepositoryCredentials" + Prelude.<$> repositoryCredentials, + (JSON..=) "ResourceRequirements" Prelude.<$> resourceRequirements, + (JSON..=) "RuntimePlatform" Prelude.<$> runtimePlatform, + (JSON..=) "Secrets" Prelude.<$> secrets, + (JSON..=) "Ulimits" Prelude.<$> ulimits, + (JSON..=) "User" Prelude.<$> user, + (JSON..=) "Vcpus" Prelude.<$> vcpus, + (JSON..=) "Volumes" Prelude.<$> volumes]))) +instance Property "Command" MultiNodeContainerPropertiesProperty where + type PropertyType "Command" MultiNodeContainerPropertiesProperty = ValueList Prelude.Text + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {command = Prelude.pure newValue, ..} +instance Property "EnableExecuteCommand" MultiNodeContainerPropertiesProperty where + type PropertyType "EnableExecuteCommand" MultiNodeContainerPropertiesProperty = Value Prelude.Bool + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {enableExecuteCommand = Prelude.pure newValue, ..} +instance Property "Environment" MultiNodeContainerPropertiesProperty where + type PropertyType "Environment" MultiNodeContainerPropertiesProperty = [EnvironmentProperty] + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {environment = Prelude.pure newValue, ..} +instance Property "EphemeralStorage" MultiNodeContainerPropertiesProperty where + type PropertyType "EphemeralStorage" MultiNodeContainerPropertiesProperty = EphemeralStorageProperty + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {ephemeralStorage = Prelude.pure newValue, ..} +instance Property "ExecutionRoleArn" MultiNodeContainerPropertiesProperty where + type PropertyType "ExecutionRoleArn" MultiNodeContainerPropertiesProperty = Value Prelude.Text + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {executionRoleArn = Prelude.pure newValue, ..} +instance Property "Image" MultiNodeContainerPropertiesProperty where + type PropertyType "Image" MultiNodeContainerPropertiesProperty = Value Prelude.Text + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty {image = newValue, ..} +instance Property "InstanceType" MultiNodeContainerPropertiesProperty where + type PropertyType "InstanceType" MultiNodeContainerPropertiesProperty = Value Prelude.Text + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {instanceType = Prelude.pure newValue, ..} +instance Property "JobRoleArn" MultiNodeContainerPropertiesProperty where + type PropertyType "JobRoleArn" MultiNodeContainerPropertiesProperty = Value Prelude.Text + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {jobRoleArn = Prelude.pure newValue, ..} +instance Property "LinuxParameters" MultiNodeContainerPropertiesProperty where + type PropertyType "LinuxParameters" MultiNodeContainerPropertiesProperty = LinuxParametersProperty + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {linuxParameters = Prelude.pure newValue, ..} +instance Property "LogConfiguration" MultiNodeContainerPropertiesProperty where + type PropertyType "LogConfiguration" MultiNodeContainerPropertiesProperty = LogConfigurationProperty + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {logConfiguration = Prelude.pure newValue, ..} +instance Property "Memory" MultiNodeContainerPropertiesProperty where + type PropertyType "Memory" MultiNodeContainerPropertiesProperty = Value Prelude.Integer + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {memory = Prelude.pure newValue, ..} +instance Property "MountPoints" MultiNodeContainerPropertiesProperty where + type PropertyType "MountPoints" MultiNodeContainerPropertiesProperty = [MountPointProperty] + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {mountPoints = Prelude.pure newValue, ..} +instance Property "Privileged" MultiNodeContainerPropertiesProperty where + type PropertyType "Privileged" MultiNodeContainerPropertiesProperty = Value Prelude.Bool + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {privileged = Prelude.pure newValue, ..} +instance Property "ReadonlyRootFilesystem" MultiNodeContainerPropertiesProperty where + type PropertyType "ReadonlyRootFilesystem" MultiNodeContainerPropertiesProperty = Value Prelude.Bool + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {readonlyRootFilesystem = Prelude.pure newValue, ..} +instance Property "RepositoryCredentials" MultiNodeContainerPropertiesProperty where + type PropertyType "RepositoryCredentials" MultiNodeContainerPropertiesProperty = RepositoryCredentialsProperty + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {repositoryCredentials = Prelude.pure newValue, ..} +instance Property "ResourceRequirements" MultiNodeContainerPropertiesProperty where + type PropertyType "ResourceRequirements" MultiNodeContainerPropertiesProperty = [ResourceRequirementProperty] + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {resourceRequirements = Prelude.pure newValue, ..} +instance Property "RuntimePlatform" MultiNodeContainerPropertiesProperty where + type PropertyType "RuntimePlatform" MultiNodeContainerPropertiesProperty = RuntimePlatformProperty + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {runtimePlatform = Prelude.pure newValue, ..} +instance Property "Secrets" MultiNodeContainerPropertiesProperty where + type PropertyType "Secrets" MultiNodeContainerPropertiesProperty = [SecretProperty] + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {secrets = Prelude.pure newValue, ..} +instance Property "Ulimits" MultiNodeContainerPropertiesProperty where + type PropertyType "Ulimits" MultiNodeContainerPropertiesProperty = [UlimitProperty] + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {ulimits = Prelude.pure newValue, ..} +instance Property "User" MultiNodeContainerPropertiesProperty where + type PropertyType "User" MultiNodeContainerPropertiesProperty = Value Prelude.Text + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {user = Prelude.pure newValue, ..} +instance Property "Vcpus" MultiNodeContainerPropertiesProperty where + type PropertyType "Vcpus" MultiNodeContainerPropertiesProperty = Value Prelude.Integer + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {vcpus = Prelude.pure newValue, ..} +instance Property "Volumes" MultiNodeContainerPropertiesProperty where + type PropertyType "Volumes" MultiNodeContainerPropertiesProperty = [VolumeProperty] + set newValue MultiNodeContainerPropertiesProperty {..} + = MultiNodeContainerPropertiesProperty + {volumes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/MultiNodeContainerPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/MultiNodeContainerPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MultiNodeContainerPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.MultiNodeContainerPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data MultiNodeContainerPropertiesProperty :: Prelude.Type +instance ToResourceProperties MultiNodeContainerPropertiesProperty +instance Prelude.Eq MultiNodeContainerPropertiesProperty +instance Prelude.Show MultiNodeContainerPropertiesProperty +instance JSON.ToJSON MultiNodeContainerPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsPropertiesProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.Batch.JobDefinition.MultiNodeEcsPropertiesProperty ( + module Exports, MultiNodeEcsPropertiesProperty(..), + mkMultiNodeEcsPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.MultiNodeEcsTaskPropertiesProperty as Exports +import Stratosphere.ResourceProperties +data MultiNodeEcsPropertiesProperty + = -- | See: + MultiNodeEcsPropertiesProperty {haddock_workaround_ :: (), + -- | See: + taskProperties :: [MultiNodeEcsTaskPropertiesProperty]} + deriving stock (Prelude.Eq, Prelude.Show) +mkMultiNodeEcsPropertiesProperty :: + [MultiNodeEcsTaskPropertiesProperty] + -> MultiNodeEcsPropertiesProperty +mkMultiNodeEcsPropertiesProperty taskProperties + = MultiNodeEcsPropertiesProperty + {haddock_workaround_ = (), taskProperties = taskProperties} +instance ToResourceProperties MultiNodeEcsPropertiesProperty where + toResourceProperties MultiNodeEcsPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.MultiNodeEcsProperties", + supportsTags = Prelude.False, + properties = ["TaskProperties" JSON..= taskProperties]} +instance JSON.ToJSON MultiNodeEcsPropertiesProperty where + toJSON MultiNodeEcsPropertiesProperty {..} + = JSON.object ["TaskProperties" JSON..= taskProperties] +instance Property "TaskProperties" MultiNodeEcsPropertiesProperty where + type PropertyType "TaskProperties" MultiNodeEcsPropertiesProperty = [MultiNodeEcsTaskPropertiesProperty] + set newValue MultiNodeEcsPropertiesProperty {..} + = MultiNodeEcsPropertiesProperty {taskProperties = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.MultiNodeEcsPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data MultiNodeEcsPropertiesProperty :: Prelude.Type +instance ToResourceProperties MultiNodeEcsPropertiesProperty +instance Prelude.Eq MultiNodeEcsPropertiesProperty +instance Prelude.Show MultiNodeEcsPropertiesProperty +instance JSON.ToJSON MultiNodeEcsPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsTaskPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsTaskPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsTaskPropertiesProperty.hs @@ -0,0 +1,99 @@ +module Stratosphere.Batch.JobDefinition.MultiNodeEcsTaskPropertiesProperty ( + module Exports, MultiNodeEcsTaskPropertiesProperty(..), + mkMultiNodeEcsTaskPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.TaskContainerPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.VolumeProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data MultiNodeEcsTaskPropertiesProperty + = -- | See: + MultiNodeEcsTaskPropertiesProperty {haddock_workaround_ :: (), + -- | See: + containers :: (Prelude.Maybe [TaskContainerPropertiesProperty]), + -- | See: + enableExecuteCommand :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + ipcMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + pidMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + taskRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + volumes :: (Prelude.Maybe [VolumeProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkMultiNodeEcsTaskPropertiesProperty :: + MultiNodeEcsTaskPropertiesProperty +mkMultiNodeEcsTaskPropertiesProperty + = MultiNodeEcsTaskPropertiesProperty + {haddock_workaround_ = (), containers = Prelude.Nothing, + enableExecuteCommand = Prelude.Nothing, + executionRoleArn = Prelude.Nothing, ipcMode = Prelude.Nothing, + pidMode = Prelude.Nothing, taskRoleArn = Prelude.Nothing, + volumes = Prelude.Nothing} +instance ToResourceProperties MultiNodeEcsTaskPropertiesProperty where + toResourceProperties MultiNodeEcsTaskPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.MultiNodeEcsTaskProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Containers" Prelude.<$> containers, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "IpcMode" Prelude.<$> ipcMode, + (JSON..=) "PidMode" Prelude.<$> pidMode, + (JSON..=) "TaskRoleArn" Prelude.<$> taskRoleArn, + (JSON..=) "Volumes" Prelude.<$> volumes])} +instance JSON.ToJSON MultiNodeEcsTaskPropertiesProperty where + toJSON MultiNodeEcsTaskPropertiesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Containers" Prelude.<$> containers, + (JSON..=) "EnableExecuteCommand" Prelude.<$> enableExecuteCommand, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "IpcMode" Prelude.<$> ipcMode, + (JSON..=) "PidMode" Prelude.<$> pidMode, + (JSON..=) "TaskRoleArn" Prelude.<$> taskRoleArn, + (JSON..=) "Volumes" Prelude.<$> volumes])) +instance Property "Containers" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "Containers" MultiNodeEcsTaskPropertiesProperty = [TaskContainerPropertiesProperty] + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {containers = Prelude.pure newValue, ..} +instance Property "EnableExecuteCommand" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "EnableExecuteCommand" MultiNodeEcsTaskPropertiesProperty = Value Prelude.Bool + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {enableExecuteCommand = Prelude.pure newValue, ..} +instance Property "ExecutionRoleArn" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "ExecutionRoleArn" MultiNodeEcsTaskPropertiesProperty = Value Prelude.Text + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {executionRoleArn = Prelude.pure newValue, ..} +instance Property "IpcMode" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "IpcMode" MultiNodeEcsTaskPropertiesProperty = Value Prelude.Text + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {ipcMode = Prelude.pure newValue, ..} +instance Property "PidMode" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "PidMode" MultiNodeEcsTaskPropertiesProperty = Value Prelude.Text + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {pidMode = Prelude.pure newValue, ..} +instance Property "TaskRoleArn" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "TaskRoleArn" MultiNodeEcsTaskPropertiesProperty = Value Prelude.Text + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {taskRoleArn = Prelude.pure newValue, ..} +instance Property "Volumes" MultiNodeEcsTaskPropertiesProperty where + type PropertyType "Volumes" MultiNodeEcsTaskPropertiesProperty = [VolumeProperty] + set newValue MultiNodeEcsTaskPropertiesProperty {..} + = MultiNodeEcsTaskPropertiesProperty + {volumes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsTaskPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsTaskPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/MultiNodeEcsTaskPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.MultiNodeEcsTaskPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data MultiNodeEcsTaskPropertiesProperty :: Prelude.Type +instance ToResourceProperties MultiNodeEcsTaskPropertiesProperty +instance Prelude.Eq MultiNodeEcsTaskPropertiesProperty +instance Prelude.Show MultiNodeEcsTaskPropertiesProperty +instance JSON.ToJSON MultiNodeEcsTaskPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/NetworkConfigurationProperty.hs b/gen/Stratosphere/Batch/JobDefinition/NetworkConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/NetworkConfigurationProperty.hs @@ -0,0 +1,37 @@ +module Stratosphere.Batch.JobDefinition.NetworkConfigurationProperty ( + NetworkConfigurationProperty(..), mkNetworkConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data NetworkConfigurationProperty + = -- | See: + NetworkConfigurationProperty {haddock_workaround_ :: (), + -- | See: + assignPublicIp :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkNetworkConfigurationProperty :: NetworkConfigurationProperty +mkNetworkConfigurationProperty + = NetworkConfigurationProperty + {haddock_workaround_ = (), assignPublicIp = Prelude.Nothing} +instance ToResourceProperties NetworkConfigurationProperty where + toResourceProperties NetworkConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.NetworkConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AssignPublicIp" Prelude.<$> assignPublicIp])} +instance JSON.ToJSON NetworkConfigurationProperty where + toJSON NetworkConfigurationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AssignPublicIp" Prelude.<$> assignPublicIp])) +instance Property "AssignPublicIp" NetworkConfigurationProperty where + type PropertyType "AssignPublicIp" NetworkConfigurationProperty = Value Prelude.Text + set newValue NetworkConfigurationProperty {..} + = NetworkConfigurationProperty + {assignPublicIp = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/NetworkConfigurationProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/NetworkConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/NetworkConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.NetworkConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data NetworkConfigurationProperty :: Prelude.Type +instance ToResourceProperties NetworkConfigurationProperty +instance Prelude.Eq NetworkConfigurationProperty +instance Prelude.Show NetworkConfigurationProperty +instance JSON.ToJSON NetworkConfigurationProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/NodePropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/NodePropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/NodePropertiesProperty.hs @@ -0,0 +1,54 @@ +module Stratosphere.Batch.JobDefinition.NodePropertiesProperty ( + module Exports, NodePropertiesProperty(..), + mkNodePropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.NodeRangePropertyProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data NodePropertiesProperty + = -- | See: + NodePropertiesProperty {haddock_workaround_ :: (), + -- | See: + mainNode :: (Value Prelude.Integer), + -- | See: + nodeRangeProperties :: [NodeRangePropertyProperty], + -- | See: + numNodes :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkNodePropertiesProperty :: + Value Prelude.Integer + -> [NodeRangePropertyProperty] + -> Value Prelude.Integer -> NodePropertiesProperty +mkNodePropertiesProperty mainNode nodeRangeProperties numNodes + = NodePropertiesProperty + {haddock_workaround_ = (), mainNode = mainNode, + nodeRangeProperties = nodeRangeProperties, numNodes = numNodes} +instance ToResourceProperties NodePropertiesProperty where + toResourceProperties NodePropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.NodeProperties", + supportsTags = Prelude.False, + properties = ["MainNode" JSON..= mainNode, + "NodeRangeProperties" JSON..= nodeRangeProperties, + "NumNodes" JSON..= numNodes]} +instance JSON.ToJSON NodePropertiesProperty where + toJSON NodePropertiesProperty {..} + = JSON.object + ["MainNode" JSON..= mainNode, + "NodeRangeProperties" JSON..= nodeRangeProperties, + "NumNodes" JSON..= numNodes] +instance Property "MainNode" NodePropertiesProperty where + type PropertyType "MainNode" NodePropertiesProperty = Value Prelude.Integer + set newValue NodePropertiesProperty {..} + = NodePropertiesProperty {mainNode = newValue, ..} +instance Property "NodeRangeProperties" NodePropertiesProperty where + type PropertyType "NodeRangeProperties" NodePropertiesProperty = [NodeRangePropertyProperty] + set newValue NodePropertiesProperty {..} + = NodePropertiesProperty {nodeRangeProperties = newValue, ..} +instance Property "NumNodes" NodePropertiesProperty where + type PropertyType "NumNodes" NodePropertiesProperty = Value Prelude.Integer + set newValue NodePropertiesProperty {..} + = NodePropertiesProperty {numNodes = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/NodePropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/NodePropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/NodePropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.NodePropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data NodePropertiesProperty :: Prelude.Type +instance ToResourceProperties NodePropertiesProperty +instance Prelude.Eq NodePropertiesProperty +instance Prelude.Show NodePropertiesProperty +instance JSON.ToJSON NodePropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/NodeRangePropertyProperty.hs b/gen/Stratosphere/Batch/JobDefinition/NodeRangePropertyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/NodeRangePropertyProperty.hs @@ -0,0 +1,93 @@ +module Stratosphere.Batch.JobDefinition.NodeRangePropertyProperty ( + module Exports, NodeRangePropertyProperty(..), + mkNodeRangePropertyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ConsumableResourcePropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EksPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.MultiNodeContainerPropertiesProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.MultiNodeEcsPropertiesProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data NodeRangePropertyProperty + = -- | See: + NodeRangePropertyProperty {haddock_workaround_ :: (), + -- | See: + consumableResourceProperties :: (Prelude.Maybe ConsumableResourcePropertiesProperty), + -- | See: + container :: (Prelude.Maybe MultiNodeContainerPropertiesProperty), + -- | See: + ecsProperties :: (Prelude.Maybe MultiNodeEcsPropertiesProperty), + -- | See: + eksProperties :: (Prelude.Maybe EksPropertiesProperty), + -- | See: + instanceTypes :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + targetNodes :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkNodeRangePropertyProperty :: + Value Prelude.Text -> NodeRangePropertyProperty +mkNodeRangePropertyProperty targetNodes + = NodeRangePropertyProperty + {haddock_workaround_ = (), targetNodes = targetNodes, + consumableResourceProperties = Prelude.Nothing, + container = Prelude.Nothing, ecsProperties = Prelude.Nothing, + eksProperties = Prelude.Nothing, instanceTypes = Prelude.Nothing} +instance ToResourceProperties NodeRangePropertyProperty where + toResourceProperties NodeRangePropertyProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.NodeRangeProperty", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["TargetNodes" JSON..= targetNodes] + (Prelude.catMaybes + [(JSON..=) "ConsumableResourceProperties" + Prelude.<$> consumableResourceProperties, + (JSON..=) "Container" Prelude.<$> container, + (JSON..=) "EcsProperties" Prelude.<$> ecsProperties, + (JSON..=) "EksProperties" Prelude.<$> eksProperties, + (JSON..=) "InstanceTypes" Prelude.<$> instanceTypes]))} +instance JSON.ToJSON NodeRangePropertyProperty where + toJSON NodeRangePropertyProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["TargetNodes" JSON..= targetNodes] + (Prelude.catMaybes + [(JSON..=) "ConsumableResourceProperties" + Prelude.<$> consumableResourceProperties, + (JSON..=) "Container" Prelude.<$> container, + (JSON..=) "EcsProperties" Prelude.<$> ecsProperties, + (JSON..=) "EksProperties" Prelude.<$> eksProperties, + (JSON..=) "InstanceTypes" Prelude.<$> instanceTypes]))) +instance Property "ConsumableResourceProperties" NodeRangePropertyProperty where + type PropertyType "ConsumableResourceProperties" NodeRangePropertyProperty = ConsumableResourcePropertiesProperty + set newValue NodeRangePropertyProperty {..} + = NodeRangePropertyProperty + {consumableResourceProperties = Prelude.pure newValue, ..} +instance Property "Container" NodeRangePropertyProperty where + type PropertyType "Container" NodeRangePropertyProperty = MultiNodeContainerPropertiesProperty + set newValue NodeRangePropertyProperty {..} + = NodeRangePropertyProperty {container = Prelude.pure newValue, ..} +instance Property "EcsProperties" NodeRangePropertyProperty where + type PropertyType "EcsProperties" NodeRangePropertyProperty = MultiNodeEcsPropertiesProperty + set newValue NodeRangePropertyProperty {..} + = NodeRangePropertyProperty + {ecsProperties = Prelude.pure newValue, ..} +instance Property "EksProperties" NodeRangePropertyProperty where + type PropertyType "EksProperties" NodeRangePropertyProperty = EksPropertiesProperty + set newValue NodeRangePropertyProperty {..} + = NodeRangePropertyProperty + {eksProperties = Prelude.pure newValue, ..} +instance Property "InstanceTypes" NodeRangePropertyProperty where + type PropertyType "InstanceTypes" NodeRangePropertyProperty = ValueList Prelude.Text + set newValue NodeRangePropertyProperty {..} + = NodeRangePropertyProperty + {instanceTypes = Prelude.pure newValue, ..} +instance Property "TargetNodes" NodeRangePropertyProperty where + type PropertyType "TargetNodes" NodeRangePropertyProperty = Value Prelude.Text + set newValue NodeRangePropertyProperty {..} + = NodeRangePropertyProperty {targetNodes = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/NodeRangePropertyProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/NodeRangePropertyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/NodeRangePropertyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.NodeRangePropertyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data NodeRangePropertyProperty :: Prelude.Type +instance ToResourceProperties NodeRangePropertyProperty +instance Prelude.Eq NodeRangePropertyProperty +instance Prelude.Show NodeRangePropertyProperty +instance JSON.ToJSON NodeRangePropertyProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/RepositoryCredentialsProperty.hs b/gen/Stratosphere/Batch/JobDefinition/RepositoryCredentialsProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/RepositoryCredentialsProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.Batch.JobDefinition.RepositoryCredentialsProperty ( + RepositoryCredentialsProperty(..), mkRepositoryCredentialsProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RepositoryCredentialsProperty + = -- | See: + RepositoryCredentialsProperty {haddock_workaround_ :: (), + -- | See: + credentialsParameter :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkRepositoryCredentialsProperty :: + Value Prelude.Text -> RepositoryCredentialsProperty +mkRepositoryCredentialsProperty credentialsParameter + = RepositoryCredentialsProperty + {haddock_workaround_ = (), + credentialsParameter = credentialsParameter} +instance ToResourceProperties RepositoryCredentialsProperty where + toResourceProperties RepositoryCredentialsProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.RepositoryCredentials", + supportsTags = Prelude.False, + properties = ["CredentialsParameter" JSON..= credentialsParameter]} +instance JSON.ToJSON RepositoryCredentialsProperty where + toJSON RepositoryCredentialsProperty {..} + = JSON.object ["CredentialsParameter" JSON..= credentialsParameter] +instance Property "CredentialsParameter" RepositoryCredentialsProperty where + type PropertyType "CredentialsParameter" RepositoryCredentialsProperty = Value Prelude.Text + set newValue RepositoryCredentialsProperty {..} + = RepositoryCredentialsProperty + {credentialsParameter = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/RepositoryCredentialsProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/RepositoryCredentialsProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/RepositoryCredentialsProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.RepositoryCredentialsProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RepositoryCredentialsProperty :: Prelude.Type +instance ToResourceProperties RepositoryCredentialsProperty +instance Prelude.Eq RepositoryCredentialsProperty +instance Prelude.Show RepositoryCredentialsProperty +instance JSON.ToJSON RepositoryCredentialsProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/ResourceRequirementProperty.hs b/gen/Stratosphere/Batch/JobDefinition/ResourceRequirementProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ResourceRequirementProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobDefinition.ResourceRequirementProperty ( + ResourceRequirementProperty(..), mkResourceRequirementProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ResourceRequirementProperty + = -- | See: + ResourceRequirementProperty {haddock_workaround_ :: (), + -- | See: + type' :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + value :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkResourceRequirementProperty :: ResourceRequirementProperty +mkResourceRequirementProperty + = ResourceRequirementProperty + {haddock_workaround_ = (), type' = Prelude.Nothing, + value = Prelude.Nothing} +instance ToResourceProperties ResourceRequirementProperty where + toResourceProperties ResourceRequirementProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.ResourceRequirement", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Type" Prelude.<$> type', + (JSON..=) "Value" Prelude.<$> value])} +instance JSON.ToJSON ResourceRequirementProperty where + toJSON ResourceRequirementProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Type" Prelude.<$> type', + (JSON..=) "Value" Prelude.<$> value])) +instance Property "Type" ResourceRequirementProperty where + type PropertyType "Type" ResourceRequirementProperty = Value Prelude.Text + set newValue ResourceRequirementProperty {..} + = ResourceRequirementProperty {type' = Prelude.pure newValue, ..} +instance Property "Value" ResourceRequirementProperty where + type PropertyType "Value" ResourceRequirementProperty = Value Prelude.Text + set newValue ResourceRequirementProperty {..} + = ResourceRequirementProperty {value = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ResourceRequirementProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/ResourceRequirementProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ResourceRequirementProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.ResourceRequirementProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ResourceRequirementProperty :: Prelude.Type +instance ToResourceProperties ResourceRequirementProperty +instance Prelude.Eq ResourceRequirementProperty +instance Prelude.Show ResourceRequirementProperty +instance JSON.ToJSON ResourceRequirementProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/ResourceRetentionPolicyProperty.hs b/gen/Stratosphere/Batch/JobDefinition/ResourceRetentionPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ResourceRetentionPolicyProperty.hs @@ -0,0 +1,42 @@ +module Stratosphere.Batch.JobDefinition.ResourceRetentionPolicyProperty ( + ResourceRetentionPolicyProperty(..), + mkResourceRetentionPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ResourceRetentionPolicyProperty + = -- | See: + ResourceRetentionPolicyProperty {haddock_workaround_ :: (), + -- | See: + skipDeregisterOnUpdate :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkResourceRetentionPolicyProperty :: + ResourceRetentionPolicyProperty +mkResourceRetentionPolicyProperty + = ResourceRetentionPolicyProperty + {haddock_workaround_ = (), + skipDeregisterOnUpdate = Prelude.Nothing} +instance ToResourceProperties ResourceRetentionPolicyProperty where + toResourceProperties ResourceRetentionPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.ResourceRetentionPolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SkipDeregisterOnUpdate" + Prelude.<$> skipDeregisterOnUpdate])} +instance JSON.ToJSON ResourceRetentionPolicyProperty where + toJSON ResourceRetentionPolicyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SkipDeregisterOnUpdate" + Prelude.<$> skipDeregisterOnUpdate])) +instance Property "SkipDeregisterOnUpdate" ResourceRetentionPolicyProperty where + type PropertyType "SkipDeregisterOnUpdate" ResourceRetentionPolicyProperty = Value Prelude.Bool + set newValue ResourceRetentionPolicyProperty {..} + = ResourceRetentionPolicyProperty + {skipDeregisterOnUpdate = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/ResourceRetentionPolicyProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/ResourceRetentionPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/ResourceRetentionPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.ResourceRetentionPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ResourceRetentionPolicyProperty :: Prelude.Type +instance ToResourceProperties ResourceRetentionPolicyProperty +instance Prelude.Eq ResourceRetentionPolicyProperty +instance Prelude.Show ResourceRetentionPolicyProperty +instance JSON.ToJSON ResourceRetentionPolicyProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/RetryStrategyProperty.hs b/gen/Stratosphere/Batch/JobDefinition/RetryStrategyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/RetryStrategyProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.Batch.JobDefinition.RetryStrategyProperty ( + module Exports, RetryStrategyProperty(..), mkRetryStrategyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EvaluateOnExitProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RetryStrategyProperty + = -- | See: + RetryStrategyProperty {haddock_workaround_ :: (), + -- | See: + attempts :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + evaluateOnExit :: (Prelude.Maybe [EvaluateOnExitProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkRetryStrategyProperty :: RetryStrategyProperty +mkRetryStrategyProperty + = RetryStrategyProperty + {haddock_workaround_ = (), attempts = Prelude.Nothing, + evaluateOnExit = Prelude.Nothing} +instance ToResourceProperties RetryStrategyProperty where + toResourceProperties RetryStrategyProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.RetryStrategy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Attempts" Prelude.<$> attempts, + (JSON..=) "EvaluateOnExit" Prelude.<$> evaluateOnExit])} +instance JSON.ToJSON RetryStrategyProperty where + toJSON RetryStrategyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Attempts" Prelude.<$> attempts, + (JSON..=) "EvaluateOnExit" Prelude.<$> evaluateOnExit])) +instance Property "Attempts" RetryStrategyProperty where + type PropertyType "Attempts" RetryStrategyProperty = Value Prelude.Integer + set newValue RetryStrategyProperty {..} + = RetryStrategyProperty {attempts = Prelude.pure newValue, ..} +instance Property "EvaluateOnExit" RetryStrategyProperty where + type PropertyType "EvaluateOnExit" RetryStrategyProperty = [EvaluateOnExitProperty] + set newValue RetryStrategyProperty {..} + = RetryStrategyProperty + {evaluateOnExit = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/RetryStrategyProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/RetryStrategyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/RetryStrategyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.RetryStrategyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RetryStrategyProperty :: Prelude.Type +instance ToResourceProperties RetryStrategyProperty +instance Prelude.Eq RetryStrategyProperty +instance Prelude.Show RetryStrategyProperty +instance JSON.ToJSON RetryStrategyProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/RuntimePlatformProperty.hs b/gen/Stratosphere/Batch/JobDefinition/RuntimePlatformProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/RuntimePlatformProperty.hs @@ -0,0 +1,49 @@ +module Stratosphere.Batch.JobDefinition.RuntimePlatformProperty ( + RuntimePlatformProperty(..), mkRuntimePlatformProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RuntimePlatformProperty + = -- | See: + RuntimePlatformProperty {haddock_workaround_ :: (), + -- | See: + cpuArchitecture :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + operatingSystemFamily :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkRuntimePlatformProperty :: RuntimePlatformProperty +mkRuntimePlatformProperty + = RuntimePlatformProperty + {haddock_workaround_ = (), cpuArchitecture = Prelude.Nothing, + operatingSystemFamily = Prelude.Nothing} +instance ToResourceProperties RuntimePlatformProperty where + toResourceProperties RuntimePlatformProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.RuntimePlatform", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CpuArchitecture" Prelude.<$> cpuArchitecture, + (JSON..=) "OperatingSystemFamily" + Prelude.<$> operatingSystemFamily])} +instance JSON.ToJSON RuntimePlatformProperty where + toJSON RuntimePlatformProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CpuArchitecture" Prelude.<$> cpuArchitecture, + (JSON..=) "OperatingSystemFamily" + Prelude.<$> operatingSystemFamily])) +instance Property "CpuArchitecture" RuntimePlatformProperty where + type PropertyType "CpuArchitecture" RuntimePlatformProperty = Value Prelude.Text + set newValue RuntimePlatformProperty {..} + = RuntimePlatformProperty + {cpuArchitecture = Prelude.pure newValue, ..} +instance Property "OperatingSystemFamily" RuntimePlatformProperty where + type PropertyType "OperatingSystemFamily" RuntimePlatformProperty = Value Prelude.Text + set newValue RuntimePlatformProperty {..} + = RuntimePlatformProperty + {operatingSystemFamily = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/RuntimePlatformProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/RuntimePlatformProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/RuntimePlatformProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.RuntimePlatformProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RuntimePlatformProperty :: Prelude.Type +instance ToResourceProperties RuntimePlatformProperty +instance Prelude.Eq RuntimePlatformProperty +instance Prelude.Show RuntimePlatformProperty +instance JSON.ToJSON RuntimePlatformProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/SecretProperty.hs b/gen/Stratosphere/Batch/JobDefinition/SecretProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/SecretProperty.hs @@ -0,0 +1,38 @@ +module Stratosphere.Batch.JobDefinition.SecretProperty ( + SecretProperty(..), mkSecretProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data SecretProperty + = -- | See: + SecretProperty {haddock_workaround_ :: (), + -- | See: + name :: (Value Prelude.Text), + -- | See: + valueFrom :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkSecretProperty :: + Value Prelude.Text -> Value Prelude.Text -> SecretProperty +mkSecretProperty name valueFrom + = SecretProperty + {haddock_workaround_ = (), name = name, valueFrom = valueFrom} +instance ToResourceProperties SecretProperty where + toResourceProperties SecretProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Secret", + supportsTags = Prelude.False, + properties = ["Name" JSON..= name, "ValueFrom" JSON..= valueFrom]} +instance JSON.ToJSON SecretProperty where + toJSON SecretProperty {..} + = JSON.object ["Name" JSON..= name, "ValueFrom" JSON..= valueFrom] +instance Property "Name" SecretProperty where + type PropertyType "Name" SecretProperty = Value Prelude.Text + set newValue SecretProperty {..} + = SecretProperty {name = newValue, ..} +instance Property "ValueFrom" SecretProperty where + type PropertyType "ValueFrom" SecretProperty = Value Prelude.Text + set newValue SecretProperty {..} + = SecretProperty {valueFrom = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/SecretProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/SecretProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/SecretProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.SecretProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data SecretProperty :: Prelude.Type +instance ToResourceProperties SecretProperty +instance Prelude.Eq SecretProperty +instance Prelude.Show SecretProperty +instance JSON.ToJSON SecretProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/TaskContainerDependencyProperty.hs b/gen/Stratosphere/Batch/JobDefinition/TaskContainerDependencyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/TaskContainerDependencyProperty.hs @@ -0,0 +1,44 @@ +module Stratosphere.Batch.JobDefinition.TaskContainerDependencyProperty ( + TaskContainerDependencyProperty(..), + mkTaskContainerDependencyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TaskContainerDependencyProperty + = -- | See: + TaskContainerDependencyProperty {haddock_workaround_ :: (), + -- | See: + condition :: (Value Prelude.Text), + -- | See: + containerName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkTaskContainerDependencyProperty :: + Value Prelude.Text + -> Value Prelude.Text -> TaskContainerDependencyProperty +mkTaskContainerDependencyProperty condition containerName + = TaskContainerDependencyProperty + {haddock_workaround_ = (), condition = condition, + containerName = containerName} +instance ToResourceProperties TaskContainerDependencyProperty where + toResourceProperties TaskContainerDependencyProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.TaskContainerDependency", + supportsTags = Prelude.False, + properties = ["Condition" JSON..= condition, + "ContainerName" JSON..= containerName]} +instance JSON.ToJSON TaskContainerDependencyProperty where + toJSON TaskContainerDependencyProperty {..} + = JSON.object + ["Condition" JSON..= condition, + "ContainerName" JSON..= containerName] +instance Property "Condition" TaskContainerDependencyProperty where + type PropertyType "Condition" TaskContainerDependencyProperty = Value Prelude.Text + set newValue TaskContainerDependencyProperty {..} + = TaskContainerDependencyProperty {condition = newValue, ..} +instance Property "ContainerName" TaskContainerDependencyProperty where + type PropertyType "ContainerName" TaskContainerDependencyProperty = Value Prelude.Text + set newValue TaskContainerDependencyProperty {..} + = TaskContainerDependencyProperty {containerName = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/TaskContainerDependencyProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/TaskContainerDependencyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/TaskContainerDependencyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.TaskContainerDependencyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data TaskContainerDependencyProperty :: Prelude.Type +instance ToResourceProperties TaskContainerDependencyProperty +instance Prelude.Eq TaskContainerDependencyProperty +instance Prelude.Show TaskContainerDependencyProperty +instance JSON.ToJSON TaskContainerDependencyProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/TaskContainerPropertiesProperty.hs b/gen/Stratosphere/Batch/JobDefinition/TaskContainerPropertiesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/TaskContainerPropertiesProperty.hs @@ -0,0 +1,210 @@ +module Stratosphere.Batch.JobDefinition.TaskContainerPropertiesProperty ( + module Exports, TaskContainerPropertiesProperty(..), + mkTaskContainerPropertiesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EnvironmentProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.FirelensConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.LinuxParametersProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.LogConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.MountPointProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.RepositoryCredentialsProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.ResourceRequirementProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.SecretProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.TaskContainerDependencyProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.UlimitProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TaskContainerPropertiesProperty + = -- | See: + TaskContainerPropertiesProperty {haddock_workaround_ :: (), + -- | See: + command :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + dependsOn :: (Prelude.Maybe [TaskContainerDependencyProperty]), + -- | See: + environment :: (Prelude.Maybe [EnvironmentProperty]), + -- | See: + essential :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + firelensConfiguration :: (Prelude.Maybe FirelensConfigurationProperty), + -- | See: + image :: (Value Prelude.Text), + -- | See: + linuxParameters :: (Prelude.Maybe LinuxParametersProperty), + -- | See: + logConfiguration :: (Prelude.Maybe LogConfigurationProperty), + -- | See: + mountPoints :: (Prelude.Maybe [MountPointProperty]), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + privileged :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + readonlyRootFilesystem :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + repositoryCredentials :: (Prelude.Maybe RepositoryCredentialsProperty), + -- | See: + resourceRequirements :: (Prelude.Maybe [ResourceRequirementProperty]), + -- | See: + secrets :: (Prelude.Maybe [SecretProperty]), + -- | See: + ulimits :: (Prelude.Maybe [UlimitProperty]), + -- | See: + user :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkTaskContainerPropertiesProperty :: + Value Prelude.Text -> TaskContainerPropertiesProperty +mkTaskContainerPropertiesProperty image + = TaskContainerPropertiesProperty + {haddock_workaround_ = (), image = image, + command = Prelude.Nothing, dependsOn = Prelude.Nothing, + environment = Prelude.Nothing, essential = Prelude.Nothing, + firelensConfiguration = Prelude.Nothing, + linuxParameters = Prelude.Nothing, + logConfiguration = Prelude.Nothing, mountPoints = Prelude.Nothing, + name = Prelude.Nothing, privileged = Prelude.Nothing, + readonlyRootFilesystem = Prelude.Nothing, + repositoryCredentials = Prelude.Nothing, + resourceRequirements = Prelude.Nothing, secrets = Prelude.Nothing, + ulimits = Prelude.Nothing, user = Prelude.Nothing} +instance ToResourceProperties TaskContainerPropertiesProperty where + toResourceProperties TaskContainerPropertiesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.TaskContainerProperties", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Command" Prelude.<$> command, + (JSON..=) "DependsOn" Prelude.<$> dependsOn, + (JSON..=) "Environment" Prelude.<$> environment, + (JSON..=) "Essential" Prelude.<$> essential, + (JSON..=) "FirelensConfiguration" + Prelude.<$> firelensConfiguration, + (JSON..=) "LinuxParameters" Prelude.<$> linuxParameters, + (JSON..=) "LogConfiguration" Prelude.<$> logConfiguration, + (JSON..=) "MountPoints" Prelude.<$> mountPoints, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadonlyRootFilesystem" + Prelude.<$> readonlyRootFilesystem, + (JSON..=) "RepositoryCredentials" + Prelude.<$> repositoryCredentials, + (JSON..=) "ResourceRequirements" Prelude.<$> resourceRequirements, + (JSON..=) "Secrets" Prelude.<$> secrets, + (JSON..=) "Ulimits" Prelude.<$> ulimits, + (JSON..=) "User" Prelude.<$> user]))} +instance JSON.ToJSON TaskContainerPropertiesProperty where + toJSON TaskContainerPropertiesProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Image" JSON..= image] + (Prelude.catMaybes + [(JSON..=) "Command" Prelude.<$> command, + (JSON..=) "DependsOn" Prelude.<$> dependsOn, + (JSON..=) "Environment" Prelude.<$> environment, + (JSON..=) "Essential" Prelude.<$> essential, + (JSON..=) "FirelensConfiguration" + Prelude.<$> firelensConfiguration, + (JSON..=) "LinuxParameters" Prelude.<$> linuxParameters, + (JSON..=) "LogConfiguration" Prelude.<$> logConfiguration, + (JSON..=) "MountPoints" Prelude.<$> mountPoints, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Privileged" Prelude.<$> privileged, + (JSON..=) "ReadonlyRootFilesystem" + Prelude.<$> readonlyRootFilesystem, + (JSON..=) "RepositoryCredentials" + Prelude.<$> repositoryCredentials, + (JSON..=) "ResourceRequirements" Prelude.<$> resourceRequirements, + (JSON..=) "Secrets" Prelude.<$> secrets, + (JSON..=) "Ulimits" Prelude.<$> ulimits, + (JSON..=) "User" Prelude.<$> user]))) +instance Property "Command" TaskContainerPropertiesProperty where + type PropertyType "Command" TaskContainerPropertiesProperty = ValueList Prelude.Text + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {command = Prelude.pure newValue, ..} +instance Property "DependsOn" TaskContainerPropertiesProperty where + type PropertyType "DependsOn" TaskContainerPropertiesProperty = [TaskContainerDependencyProperty] + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {dependsOn = Prelude.pure newValue, ..} +instance Property "Environment" TaskContainerPropertiesProperty where + type PropertyType "Environment" TaskContainerPropertiesProperty = [EnvironmentProperty] + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {environment = Prelude.pure newValue, ..} +instance Property "Essential" TaskContainerPropertiesProperty where + type PropertyType "Essential" TaskContainerPropertiesProperty = Value Prelude.Bool + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {essential = Prelude.pure newValue, ..} +instance Property "FirelensConfiguration" TaskContainerPropertiesProperty where + type PropertyType "FirelensConfiguration" TaskContainerPropertiesProperty = FirelensConfigurationProperty + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {firelensConfiguration = Prelude.pure newValue, ..} +instance Property "Image" TaskContainerPropertiesProperty where + type PropertyType "Image" TaskContainerPropertiesProperty = Value Prelude.Text + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty {image = newValue, ..} +instance Property "LinuxParameters" TaskContainerPropertiesProperty where + type PropertyType "LinuxParameters" TaskContainerPropertiesProperty = LinuxParametersProperty + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {linuxParameters = Prelude.pure newValue, ..} +instance Property "LogConfiguration" TaskContainerPropertiesProperty where + type PropertyType "LogConfiguration" TaskContainerPropertiesProperty = LogConfigurationProperty + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {logConfiguration = Prelude.pure newValue, ..} +instance Property "MountPoints" TaskContainerPropertiesProperty where + type PropertyType "MountPoints" TaskContainerPropertiesProperty = [MountPointProperty] + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {mountPoints = Prelude.pure newValue, ..} +instance Property "Name" TaskContainerPropertiesProperty where + type PropertyType "Name" TaskContainerPropertiesProperty = Value Prelude.Text + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {name = Prelude.pure newValue, ..} +instance Property "Privileged" TaskContainerPropertiesProperty where + type PropertyType "Privileged" TaskContainerPropertiesProperty = Value Prelude.Bool + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {privileged = Prelude.pure newValue, ..} +instance Property "ReadonlyRootFilesystem" TaskContainerPropertiesProperty where + type PropertyType "ReadonlyRootFilesystem" TaskContainerPropertiesProperty = Value Prelude.Bool + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {readonlyRootFilesystem = Prelude.pure newValue, ..} +instance Property "RepositoryCredentials" TaskContainerPropertiesProperty where + type PropertyType "RepositoryCredentials" TaskContainerPropertiesProperty = RepositoryCredentialsProperty + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {repositoryCredentials = Prelude.pure newValue, ..} +instance Property "ResourceRequirements" TaskContainerPropertiesProperty where + type PropertyType "ResourceRequirements" TaskContainerPropertiesProperty = [ResourceRequirementProperty] + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {resourceRequirements = Prelude.pure newValue, ..} +instance Property "Secrets" TaskContainerPropertiesProperty where + type PropertyType "Secrets" TaskContainerPropertiesProperty = [SecretProperty] + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {secrets = Prelude.pure newValue, ..} +instance Property "Ulimits" TaskContainerPropertiesProperty where + type PropertyType "Ulimits" TaskContainerPropertiesProperty = [UlimitProperty] + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {ulimits = Prelude.pure newValue, ..} +instance Property "User" TaskContainerPropertiesProperty where + type PropertyType "User" TaskContainerPropertiesProperty = Value Prelude.Text + set newValue TaskContainerPropertiesProperty {..} + = TaskContainerPropertiesProperty + {user = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/TaskContainerPropertiesProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/TaskContainerPropertiesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/TaskContainerPropertiesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.TaskContainerPropertiesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data TaskContainerPropertiesProperty :: Prelude.Type +instance ToResourceProperties TaskContainerPropertiesProperty +instance Prelude.Eq TaskContainerPropertiesProperty +instance Prelude.Show TaskContainerPropertiesProperty +instance JSON.ToJSON TaskContainerPropertiesProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/TmpfsProperty.hs b/gen/Stratosphere/Batch/JobDefinition/TmpfsProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/TmpfsProperty.hs @@ -0,0 +1,54 @@ +module Stratosphere.Batch.JobDefinition.TmpfsProperty ( + TmpfsProperty(..), mkTmpfsProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TmpfsProperty + = -- | See: + TmpfsProperty {haddock_workaround_ :: (), + -- | See: + containerPath :: (Value Prelude.Text), + -- | See: + mountOptions :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + size :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkTmpfsProperty :: + Value Prelude.Text -> Value Prelude.Integer -> TmpfsProperty +mkTmpfsProperty containerPath size + = TmpfsProperty + {haddock_workaround_ = (), containerPath = containerPath, + size = size, mountOptions = Prelude.Nothing} +instance ToResourceProperties TmpfsProperty where + toResourceProperties TmpfsProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Tmpfs", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ContainerPath" JSON..= containerPath, "Size" JSON..= size] + (Prelude.catMaybes + [(JSON..=) "MountOptions" Prelude.<$> mountOptions]))} +instance JSON.ToJSON TmpfsProperty where + toJSON TmpfsProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ContainerPath" JSON..= containerPath, "Size" JSON..= size] + (Prelude.catMaybes + [(JSON..=) "MountOptions" Prelude.<$> mountOptions]))) +instance Property "ContainerPath" TmpfsProperty where + type PropertyType "ContainerPath" TmpfsProperty = Value Prelude.Text + set newValue TmpfsProperty {..} + = TmpfsProperty {containerPath = newValue, ..} +instance Property "MountOptions" TmpfsProperty where + type PropertyType "MountOptions" TmpfsProperty = ValueList Prelude.Text + set newValue TmpfsProperty {..} + = TmpfsProperty {mountOptions = Prelude.pure newValue, ..} +instance Property "Size" TmpfsProperty where + type PropertyType "Size" TmpfsProperty = Value Prelude.Integer + set newValue TmpfsProperty {..} + = TmpfsProperty {size = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/TmpfsProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/TmpfsProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/TmpfsProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.TmpfsProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data TmpfsProperty :: Prelude.Type +instance ToResourceProperties TmpfsProperty +instance Prelude.Eq TmpfsProperty +instance Prelude.Show TmpfsProperty +instance JSON.ToJSON TmpfsProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/UlimitProperty.hs b/gen/Stratosphere/Batch/JobDefinition/UlimitProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/UlimitProperty.hs @@ -0,0 +1,49 @@ +module Stratosphere.Batch.JobDefinition.UlimitProperty ( + UlimitProperty(..), mkUlimitProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data UlimitProperty + = -- | See: + UlimitProperty {haddock_workaround_ :: (), + -- | See: + hardLimit :: (Value Prelude.Integer), + -- | See: + name :: (Value Prelude.Text), + -- | See: + softLimit :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkUlimitProperty :: + Value Prelude.Integer + -> Value Prelude.Text -> Value Prelude.Integer -> UlimitProperty +mkUlimitProperty hardLimit name softLimit + = UlimitProperty + {haddock_workaround_ = (), hardLimit = hardLimit, name = name, + softLimit = softLimit} +instance ToResourceProperties UlimitProperty where + toResourceProperties UlimitProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Ulimit", + supportsTags = Prelude.False, + properties = ["HardLimit" JSON..= hardLimit, "Name" JSON..= name, + "SoftLimit" JSON..= softLimit]} +instance JSON.ToJSON UlimitProperty where + toJSON UlimitProperty {..} + = JSON.object + ["HardLimit" JSON..= hardLimit, "Name" JSON..= name, + "SoftLimit" JSON..= softLimit] +instance Property "HardLimit" UlimitProperty where + type PropertyType "HardLimit" UlimitProperty = Value Prelude.Integer + set newValue UlimitProperty {..} + = UlimitProperty {hardLimit = newValue, ..} +instance Property "Name" UlimitProperty where + type PropertyType "Name" UlimitProperty = Value Prelude.Text + set newValue UlimitProperty {..} + = UlimitProperty {name = newValue, ..} +instance Property "SoftLimit" UlimitProperty where + type PropertyType "SoftLimit" UlimitProperty = Value Prelude.Integer + set newValue UlimitProperty {..} + = UlimitProperty {softLimit = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/UlimitProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/UlimitProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/UlimitProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.UlimitProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data UlimitProperty :: Prelude.Type +instance ToResourceProperties UlimitProperty +instance Prelude.Eq UlimitProperty +instance Prelude.Show UlimitProperty +instance JSON.ToJSON UlimitProperty diff --git a/gen/Stratosphere/Batch/JobDefinition/VolumeProperty.hs b/gen/Stratosphere/Batch/JobDefinition/VolumeProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/VolumeProperty.hs @@ -0,0 +1,59 @@ +module Stratosphere.Batch.JobDefinition.VolumeProperty ( + module Exports, VolumeProperty(..), mkVolumeProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.EFSVolumeConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobDefinition.HostProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data VolumeProperty + = -- | See: + VolumeProperty {haddock_workaround_ :: (), + -- | See: + efsVolumeConfiguration :: (Prelude.Maybe EFSVolumeConfigurationProperty), + -- | See: + host :: (Prelude.Maybe HostProperty), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkVolumeProperty :: VolumeProperty +mkVolumeProperty + = VolumeProperty + {haddock_workaround_ = (), + efsVolumeConfiguration = Prelude.Nothing, host = Prelude.Nothing, + name = Prelude.Nothing} +instance ToResourceProperties VolumeProperty where + toResourceProperties VolumeProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobDefinition.Volume", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "EfsVolumeConfiguration" + Prelude.<$> efsVolumeConfiguration, + (JSON..=) "Host" Prelude.<$> host, + (JSON..=) "Name" Prelude.<$> name])} +instance JSON.ToJSON VolumeProperty where + toJSON VolumeProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "EfsVolumeConfiguration" + Prelude.<$> efsVolumeConfiguration, + (JSON..=) "Host" Prelude.<$> host, + (JSON..=) "Name" Prelude.<$> name])) +instance Property "EfsVolumeConfiguration" VolumeProperty where + type PropertyType "EfsVolumeConfiguration" VolumeProperty = EFSVolumeConfigurationProperty + set newValue VolumeProperty {..} + = VolumeProperty + {efsVolumeConfiguration = Prelude.pure newValue, ..} +instance Property "Host" VolumeProperty where + type PropertyType "Host" VolumeProperty = HostProperty + set newValue VolumeProperty {..} + = VolumeProperty {host = Prelude.pure newValue, ..} +instance Property "Name" VolumeProperty where + type PropertyType "Name" VolumeProperty = Value Prelude.Text + set newValue VolumeProperty {..} + = VolumeProperty {name = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobDefinition/VolumeProperty.hs-boot b/gen/Stratosphere/Batch/JobDefinition/VolumeProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobDefinition/VolumeProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobDefinition.VolumeProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data VolumeProperty :: Prelude.Type +instance ToResourceProperties VolumeProperty +instance Prelude.Eq VolumeProperty +instance Prelude.Show VolumeProperty +instance JSON.ToJSON VolumeProperty diff --git a/gen/Stratosphere/Batch/JobQueue.hs b/gen/Stratosphere/Batch/JobQueue.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue.hs @@ -0,0 +1,115 @@ +module Stratosphere.Batch.JobQueue ( + module Exports, JobQueue(..), mkJobQueue + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.JobQueue.ComputeEnvironmentOrderProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobQueue.JobStateTimeLimitActionProperty as Exports +import {-# SOURCE #-} Stratosphere.Batch.JobQueue.ServiceEnvironmentOrderProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data JobQueue + = -- | See: + JobQueue {haddock_workaround_ :: (), + -- | See: + computeEnvironmentOrder :: (Prelude.Maybe [ComputeEnvironmentOrderProperty]), + -- | See: + jobQueueName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + jobQueueType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + jobStateTimeLimitActions :: (Prelude.Maybe [JobStateTimeLimitActionProperty]), + -- | See: + priority :: (Value Prelude.Integer), + -- | See: + schedulingPolicyArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + serviceEnvironmentOrder :: (Prelude.Maybe [ServiceEnvironmentOrderProperty]), + -- | See: + state :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text)))} + deriving stock (Prelude.Eq, Prelude.Show) +mkJobQueue :: Value Prelude.Integer -> JobQueue +mkJobQueue priority + = JobQueue + {haddock_workaround_ = (), priority = priority, + computeEnvironmentOrder = Prelude.Nothing, + jobQueueName = Prelude.Nothing, jobQueueType = Prelude.Nothing, + jobStateTimeLimitActions = Prelude.Nothing, + schedulingPolicyArn = Prelude.Nothing, + serviceEnvironmentOrder = Prelude.Nothing, state = Prelude.Nothing, + tags = Prelude.Nothing} +instance ToResourceProperties JobQueue where + toResourceProperties JobQueue {..} + = ResourceProperties + {awsType = "AWS::Batch::JobQueue", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Priority" JSON..= priority] + (Prelude.catMaybes + [(JSON..=) "ComputeEnvironmentOrder" + Prelude.<$> computeEnvironmentOrder, + (JSON..=) "JobQueueName" Prelude.<$> jobQueueName, + (JSON..=) "JobQueueType" Prelude.<$> jobQueueType, + (JSON..=) "JobStateTimeLimitActions" + Prelude.<$> jobStateTimeLimitActions, + (JSON..=) "SchedulingPolicyArn" Prelude.<$> schedulingPolicyArn, + (JSON..=) "ServiceEnvironmentOrder" + Prelude.<$> serviceEnvironmentOrder, + (JSON..=) "State" Prelude.<$> state, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON JobQueue where + toJSON JobQueue {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Priority" JSON..= priority] + (Prelude.catMaybes + [(JSON..=) "ComputeEnvironmentOrder" + Prelude.<$> computeEnvironmentOrder, + (JSON..=) "JobQueueName" Prelude.<$> jobQueueName, + (JSON..=) "JobQueueType" Prelude.<$> jobQueueType, + (JSON..=) "JobStateTimeLimitActions" + Prelude.<$> jobStateTimeLimitActions, + (JSON..=) "SchedulingPolicyArn" Prelude.<$> schedulingPolicyArn, + (JSON..=) "ServiceEnvironmentOrder" + Prelude.<$> serviceEnvironmentOrder, + (JSON..=) "State" Prelude.<$> state, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "ComputeEnvironmentOrder" JobQueue where + type PropertyType "ComputeEnvironmentOrder" JobQueue = [ComputeEnvironmentOrderProperty] + set newValue JobQueue {..} + = JobQueue {computeEnvironmentOrder = Prelude.pure newValue, ..} +instance Property "JobQueueName" JobQueue where + type PropertyType "JobQueueName" JobQueue = Value Prelude.Text + set newValue JobQueue {..} + = JobQueue {jobQueueName = Prelude.pure newValue, ..} +instance Property "JobQueueType" JobQueue where + type PropertyType "JobQueueType" JobQueue = Value Prelude.Text + set newValue JobQueue {..} + = JobQueue {jobQueueType = Prelude.pure newValue, ..} +instance Property "JobStateTimeLimitActions" JobQueue where + type PropertyType "JobStateTimeLimitActions" JobQueue = [JobStateTimeLimitActionProperty] + set newValue JobQueue {..} + = JobQueue {jobStateTimeLimitActions = Prelude.pure newValue, ..} +instance Property "Priority" JobQueue where + type PropertyType "Priority" JobQueue = Value Prelude.Integer + set newValue JobQueue {..} = JobQueue {priority = newValue, ..} +instance Property "SchedulingPolicyArn" JobQueue where + type PropertyType "SchedulingPolicyArn" JobQueue = Value Prelude.Text + set newValue JobQueue {..} + = JobQueue {schedulingPolicyArn = Prelude.pure newValue, ..} +instance Property "ServiceEnvironmentOrder" JobQueue where + type PropertyType "ServiceEnvironmentOrder" JobQueue = [ServiceEnvironmentOrderProperty] + set newValue JobQueue {..} + = JobQueue {serviceEnvironmentOrder = Prelude.pure newValue, ..} +instance Property "State" JobQueue where + type PropertyType "State" JobQueue = Value Prelude.Text + set newValue JobQueue {..} + = JobQueue {state = Prelude.pure newValue, ..} +instance Property "Tags" JobQueue where + type PropertyType "Tags" JobQueue = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue JobQueue {..} + = JobQueue {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/JobQueue/ComputeEnvironmentOrderProperty.hs b/gen/Stratosphere/Batch/JobQueue/ComputeEnvironmentOrderProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue/ComputeEnvironmentOrderProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobQueue.ComputeEnvironmentOrderProperty ( + ComputeEnvironmentOrderProperty(..), + mkComputeEnvironmentOrderProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ComputeEnvironmentOrderProperty + = -- | See: + ComputeEnvironmentOrderProperty {haddock_workaround_ :: (), + -- | See: + computeEnvironment :: (Value Prelude.Text), + -- | See: + order :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkComputeEnvironmentOrderProperty :: + Value Prelude.Text + -> Value Prelude.Integer -> ComputeEnvironmentOrderProperty +mkComputeEnvironmentOrderProperty computeEnvironment order + = ComputeEnvironmentOrderProperty + {haddock_workaround_ = (), computeEnvironment = computeEnvironment, + order = order} +instance ToResourceProperties ComputeEnvironmentOrderProperty where + toResourceProperties ComputeEnvironmentOrderProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobQueue.ComputeEnvironmentOrder", + supportsTags = Prelude.False, + properties = ["ComputeEnvironment" JSON..= computeEnvironment, + "Order" JSON..= order]} +instance JSON.ToJSON ComputeEnvironmentOrderProperty where + toJSON ComputeEnvironmentOrderProperty {..} + = JSON.object + ["ComputeEnvironment" JSON..= computeEnvironment, + "Order" JSON..= order] +instance Property "ComputeEnvironment" ComputeEnvironmentOrderProperty where + type PropertyType "ComputeEnvironment" ComputeEnvironmentOrderProperty = Value Prelude.Text + set newValue ComputeEnvironmentOrderProperty {..} + = ComputeEnvironmentOrderProperty + {computeEnvironment = newValue, ..} +instance Property "Order" ComputeEnvironmentOrderProperty where + type PropertyType "Order" ComputeEnvironmentOrderProperty = Value Prelude.Integer + set newValue ComputeEnvironmentOrderProperty {..} + = ComputeEnvironmentOrderProperty {order = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobQueue/ComputeEnvironmentOrderProperty.hs-boot b/gen/Stratosphere/Batch/JobQueue/ComputeEnvironmentOrderProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue/ComputeEnvironmentOrderProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobQueue.ComputeEnvironmentOrderProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ComputeEnvironmentOrderProperty :: Prelude.Type +instance ToResourceProperties ComputeEnvironmentOrderProperty +instance Prelude.Eq ComputeEnvironmentOrderProperty +instance Prelude.Show ComputeEnvironmentOrderProperty +instance JSON.ToJSON ComputeEnvironmentOrderProperty diff --git a/gen/Stratosphere/Batch/JobQueue/JobStateTimeLimitActionProperty.hs b/gen/Stratosphere/Batch/JobQueue/JobStateTimeLimitActionProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue/JobStateTimeLimitActionProperty.hs @@ -0,0 +1,63 @@ +module Stratosphere.Batch.JobQueue.JobStateTimeLimitActionProperty ( + JobStateTimeLimitActionProperty(..), + mkJobStateTimeLimitActionProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data JobStateTimeLimitActionProperty + = -- | See: + JobStateTimeLimitActionProperty {haddock_workaround_ :: (), + -- | See: + action :: (Value Prelude.Text), + -- | See: + maxTimeSeconds :: (Value Prelude.Integer), + -- | See: + reason :: (Value Prelude.Text), + -- | See: + state :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkJobStateTimeLimitActionProperty :: + Value Prelude.Text + -> Value Prelude.Integer + -> Value Prelude.Text + -> Value Prelude.Text -> JobStateTimeLimitActionProperty +mkJobStateTimeLimitActionProperty + action + maxTimeSeconds + reason + state + = JobStateTimeLimitActionProperty + {haddock_workaround_ = (), action = action, + maxTimeSeconds = maxTimeSeconds, reason = reason, state = state} +instance ToResourceProperties JobStateTimeLimitActionProperty where + toResourceProperties JobStateTimeLimitActionProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobQueue.JobStateTimeLimitAction", + supportsTags = Prelude.False, + properties = ["Action" JSON..= action, + "MaxTimeSeconds" JSON..= maxTimeSeconds, "Reason" JSON..= reason, + "State" JSON..= state]} +instance JSON.ToJSON JobStateTimeLimitActionProperty where + toJSON JobStateTimeLimitActionProperty {..} + = JSON.object + ["Action" JSON..= action, "MaxTimeSeconds" JSON..= maxTimeSeconds, + "Reason" JSON..= reason, "State" JSON..= state] +instance Property "Action" JobStateTimeLimitActionProperty where + type PropertyType "Action" JobStateTimeLimitActionProperty = Value Prelude.Text + set newValue JobStateTimeLimitActionProperty {..} + = JobStateTimeLimitActionProperty {action = newValue, ..} +instance Property "MaxTimeSeconds" JobStateTimeLimitActionProperty where + type PropertyType "MaxTimeSeconds" JobStateTimeLimitActionProperty = Value Prelude.Integer + set newValue JobStateTimeLimitActionProperty {..} + = JobStateTimeLimitActionProperty {maxTimeSeconds = newValue, ..} +instance Property "Reason" JobStateTimeLimitActionProperty where + type PropertyType "Reason" JobStateTimeLimitActionProperty = Value Prelude.Text + set newValue JobStateTimeLimitActionProperty {..} + = JobStateTimeLimitActionProperty {reason = newValue, ..} +instance Property "State" JobStateTimeLimitActionProperty where + type PropertyType "State" JobStateTimeLimitActionProperty = Value Prelude.Text + set newValue JobStateTimeLimitActionProperty {..} + = JobStateTimeLimitActionProperty {state = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobQueue/JobStateTimeLimitActionProperty.hs-boot b/gen/Stratosphere/Batch/JobQueue/JobStateTimeLimitActionProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue/JobStateTimeLimitActionProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobQueue.JobStateTimeLimitActionProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data JobStateTimeLimitActionProperty :: Prelude.Type +instance ToResourceProperties JobStateTimeLimitActionProperty +instance Prelude.Eq JobStateTimeLimitActionProperty +instance Prelude.Show JobStateTimeLimitActionProperty +instance JSON.ToJSON JobStateTimeLimitActionProperty diff --git a/gen/Stratosphere/Batch/JobQueue/ServiceEnvironmentOrderProperty.hs b/gen/Stratosphere/Batch/JobQueue/ServiceEnvironmentOrderProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue/ServiceEnvironmentOrderProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.JobQueue.ServiceEnvironmentOrderProperty ( + ServiceEnvironmentOrderProperty(..), + mkServiceEnvironmentOrderProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ServiceEnvironmentOrderProperty + = -- | See: + ServiceEnvironmentOrderProperty {haddock_workaround_ :: (), + -- | See: + order :: (Value Prelude.Integer), + -- | See: + serviceEnvironment :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkServiceEnvironmentOrderProperty :: + Value Prelude.Integer + -> Value Prelude.Text -> ServiceEnvironmentOrderProperty +mkServiceEnvironmentOrderProperty order serviceEnvironment + = ServiceEnvironmentOrderProperty + {haddock_workaround_ = (), order = order, + serviceEnvironment = serviceEnvironment} +instance ToResourceProperties ServiceEnvironmentOrderProperty where + toResourceProperties ServiceEnvironmentOrderProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::JobQueue.ServiceEnvironmentOrder", + supportsTags = Prelude.False, + properties = ["Order" JSON..= order, + "ServiceEnvironment" JSON..= serviceEnvironment]} +instance JSON.ToJSON ServiceEnvironmentOrderProperty where + toJSON ServiceEnvironmentOrderProperty {..} + = JSON.object + ["Order" JSON..= order, + "ServiceEnvironment" JSON..= serviceEnvironment] +instance Property "Order" ServiceEnvironmentOrderProperty where + type PropertyType "Order" ServiceEnvironmentOrderProperty = Value Prelude.Integer + set newValue ServiceEnvironmentOrderProperty {..} + = ServiceEnvironmentOrderProperty {order = newValue, ..} +instance Property "ServiceEnvironment" ServiceEnvironmentOrderProperty where + type PropertyType "ServiceEnvironment" ServiceEnvironmentOrderProperty = Value Prelude.Text + set newValue ServiceEnvironmentOrderProperty {..} + = ServiceEnvironmentOrderProperty + {serviceEnvironment = newValue, ..} diff --git a/gen/Stratosphere/Batch/JobQueue/ServiceEnvironmentOrderProperty.hs-boot b/gen/Stratosphere/Batch/JobQueue/ServiceEnvironmentOrderProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/JobQueue/ServiceEnvironmentOrderProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.JobQueue.ServiceEnvironmentOrderProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ServiceEnvironmentOrderProperty :: Prelude.Type +instance ToResourceProperties ServiceEnvironmentOrderProperty +instance Prelude.Eq ServiceEnvironmentOrderProperty +instance Prelude.Show ServiceEnvironmentOrderProperty +instance JSON.ToJSON ServiceEnvironmentOrderProperty diff --git a/gen/Stratosphere/Batch/SchedulingPolicy.hs b/gen/Stratosphere/Batch/SchedulingPolicy.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/SchedulingPolicy.hs @@ -0,0 +1,54 @@ +module Stratosphere.Batch.SchedulingPolicy ( + module Exports, SchedulingPolicy(..), mkSchedulingPolicy + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.SchedulingPolicy.FairsharePolicyProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data SchedulingPolicy + = -- | See: + SchedulingPolicy {haddock_workaround_ :: (), + -- | See: + fairsharePolicy :: (Prelude.Maybe FairsharePolicyProperty), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text)))} + deriving stock (Prelude.Eq, Prelude.Show) +mkSchedulingPolicy :: SchedulingPolicy +mkSchedulingPolicy + = SchedulingPolicy + {haddock_workaround_ = (), fairsharePolicy = Prelude.Nothing, + name = Prelude.Nothing, tags = Prelude.Nothing} +instance ToResourceProperties SchedulingPolicy where + toResourceProperties SchedulingPolicy {..} + = ResourceProperties + {awsType = "AWS::Batch::SchedulingPolicy", + supportsTags = Prelude.True, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "FairsharePolicy" Prelude.<$> fairsharePolicy, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Tags" Prelude.<$> tags])} +instance JSON.ToJSON SchedulingPolicy where + toJSON SchedulingPolicy {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "FairsharePolicy" Prelude.<$> fairsharePolicy, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Tags" Prelude.<$> tags])) +instance Property "FairsharePolicy" SchedulingPolicy where + type PropertyType "FairsharePolicy" SchedulingPolicy = FairsharePolicyProperty + set newValue SchedulingPolicy {..} + = SchedulingPolicy {fairsharePolicy = Prelude.pure newValue, ..} +instance Property "Name" SchedulingPolicy where + type PropertyType "Name" SchedulingPolicy = Value Prelude.Text + set newValue SchedulingPolicy {..} + = SchedulingPolicy {name = Prelude.pure newValue, ..} +instance Property "Tags" SchedulingPolicy where + type PropertyType "Tags" SchedulingPolicy = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue SchedulingPolicy {..} + = SchedulingPolicy {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/SchedulingPolicy/FairsharePolicyProperty.hs b/gen/Stratosphere/Batch/SchedulingPolicy/FairsharePolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/SchedulingPolicy/FairsharePolicyProperty.hs @@ -0,0 +1,59 @@ +module Stratosphere.Batch.SchedulingPolicy.FairsharePolicyProperty ( + module Exports, FairsharePolicyProperty(..), + mkFairsharePolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.SchedulingPolicy.ShareAttributesProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data FairsharePolicyProperty + = -- | See: + FairsharePolicyProperty {haddock_workaround_ :: (), + -- | See: + computeReservation :: (Prelude.Maybe (Value Prelude.Double)), + -- | See: + shareDecaySeconds :: (Prelude.Maybe (Value Prelude.Double)), + -- | See: + shareDistribution :: (Prelude.Maybe [ShareAttributesProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkFairsharePolicyProperty :: FairsharePolicyProperty +mkFairsharePolicyProperty + = FairsharePolicyProperty + {haddock_workaround_ = (), computeReservation = Prelude.Nothing, + shareDecaySeconds = Prelude.Nothing, + shareDistribution = Prelude.Nothing} +instance ToResourceProperties FairsharePolicyProperty where + toResourceProperties FairsharePolicyProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::SchedulingPolicy.FairsharePolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ComputeReservation" Prelude.<$> computeReservation, + (JSON..=) "ShareDecaySeconds" Prelude.<$> shareDecaySeconds, + (JSON..=) "ShareDistribution" Prelude.<$> shareDistribution])} +instance JSON.ToJSON FairsharePolicyProperty where + toJSON FairsharePolicyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ComputeReservation" Prelude.<$> computeReservation, + (JSON..=) "ShareDecaySeconds" Prelude.<$> shareDecaySeconds, + (JSON..=) "ShareDistribution" Prelude.<$> shareDistribution])) +instance Property "ComputeReservation" FairsharePolicyProperty where + type PropertyType "ComputeReservation" FairsharePolicyProperty = Value Prelude.Double + set newValue FairsharePolicyProperty {..} + = FairsharePolicyProperty + {computeReservation = Prelude.pure newValue, ..} +instance Property "ShareDecaySeconds" FairsharePolicyProperty where + type PropertyType "ShareDecaySeconds" FairsharePolicyProperty = Value Prelude.Double + set newValue FairsharePolicyProperty {..} + = FairsharePolicyProperty + {shareDecaySeconds = Prelude.pure newValue, ..} +instance Property "ShareDistribution" FairsharePolicyProperty where + type PropertyType "ShareDistribution" FairsharePolicyProperty = [ShareAttributesProperty] + set newValue FairsharePolicyProperty {..} + = FairsharePolicyProperty + {shareDistribution = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/SchedulingPolicy/FairsharePolicyProperty.hs-boot b/gen/Stratosphere/Batch/SchedulingPolicy/FairsharePolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/SchedulingPolicy/FairsharePolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.SchedulingPolicy.FairsharePolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data FairsharePolicyProperty :: Prelude.Type +instance ToResourceProperties FairsharePolicyProperty +instance Prelude.Eq FairsharePolicyProperty +instance Prelude.Show FairsharePolicyProperty +instance JSON.ToJSON FairsharePolicyProperty diff --git a/gen/Stratosphere/Batch/SchedulingPolicy/ShareAttributesProperty.hs b/gen/Stratosphere/Batch/SchedulingPolicy/ShareAttributesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/SchedulingPolicy/ShareAttributesProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.Batch.SchedulingPolicy.ShareAttributesProperty ( + ShareAttributesProperty(..), mkShareAttributesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ShareAttributesProperty + = -- | See: + ShareAttributesProperty {haddock_workaround_ :: (), + -- | See: + shareIdentifier :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + weightFactor :: (Prelude.Maybe (Value Prelude.Double))} + deriving stock (Prelude.Eq, Prelude.Show) +mkShareAttributesProperty :: ShareAttributesProperty +mkShareAttributesProperty + = ShareAttributesProperty + {haddock_workaround_ = (), shareIdentifier = Prelude.Nothing, + weightFactor = Prelude.Nothing} +instance ToResourceProperties ShareAttributesProperty where + toResourceProperties ShareAttributesProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::SchedulingPolicy.ShareAttributes", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ShareIdentifier" Prelude.<$> shareIdentifier, + (JSON..=) "WeightFactor" Prelude.<$> weightFactor])} +instance JSON.ToJSON ShareAttributesProperty where + toJSON ShareAttributesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ShareIdentifier" Prelude.<$> shareIdentifier, + (JSON..=) "WeightFactor" Prelude.<$> weightFactor])) +instance Property "ShareIdentifier" ShareAttributesProperty where + type PropertyType "ShareIdentifier" ShareAttributesProperty = Value Prelude.Text + set newValue ShareAttributesProperty {..} + = ShareAttributesProperty + {shareIdentifier = Prelude.pure newValue, ..} +instance Property "WeightFactor" ShareAttributesProperty where + type PropertyType "WeightFactor" ShareAttributesProperty = Value Prelude.Double + set newValue ShareAttributesProperty {..} + = ShareAttributesProperty + {weightFactor = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/SchedulingPolicy/ShareAttributesProperty.hs-boot b/gen/Stratosphere/Batch/SchedulingPolicy/ShareAttributesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/SchedulingPolicy/ShareAttributesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.SchedulingPolicy.ShareAttributesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ShareAttributesProperty :: Prelude.Type +instance ToResourceProperties ShareAttributesProperty +instance Prelude.Eq ShareAttributesProperty +instance Prelude.Show ShareAttributesProperty +instance JSON.ToJSON ShareAttributesProperty diff --git a/gen/Stratosphere/Batch/ServiceEnvironment.hs b/gen/Stratosphere/Batch/ServiceEnvironment.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ServiceEnvironment.hs @@ -0,0 +1,78 @@ +module Stratosphere.Batch.ServiceEnvironment ( + module Exports, ServiceEnvironment(..), mkServiceEnvironment + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.Batch.ServiceEnvironment.CapacityLimitProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ServiceEnvironment + = -- | See: + ServiceEnvironment {haddock_workaround_ :: (), + -- | See: + capacityLimits :: [CapacityLimitProperty], + -- | See: + serviceEnvironmentName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + serviceEnvironmentType :: (Value Prelude.Text), + -- | See: + state :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text)))} + deriving stock (Prelude.Eq, Prelude.Show) +mkServiceEnvironment :: + [CapacityLimitProperty] -> Value Prelude.Text -> ServiceEnvironment +mkServiceEnvironment capacityLimits serviceEnvironmentType + = ServiceEnvironment + {haddock_workaround_ = (), capacityLimits = capacityLimits, + serviceEnvironmentType = serviceEnvironmentType, + serviceEnvironmentName = Prelude.Nothing, state = Prelude.Nothing, + tags = Prelude.Nothing} +instance ToResourceProperties ServiceEnvironment where + toResourceProperties ServiceEnvironment {..} + = ResourceProperties + {awsType = "AWS::Batch::ServiceEnvironment", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["CapacityLimits" JSON..= capacityLimits, + "ServiceEnvironmentType" JSON..= serviceEnvironmentType] + (Prelude.catMaybes + [(JSON..=) "ServiceEnvironmentName" + Prelude.<$> serviceEnvironmentName, + (JSON..=) "State" Prelude.<$> state, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON ServiceEnvironment where + toJSON ServiceEnvironment {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["CapacityLimits" JSON..= capacityLimits, + "ServiceEnvironmentType" JSON..= serviceEnvironmentType] + (Prelude.catMaybes + [(JSON..=) "ServiceEnvironmentName" + Prelude.<$> serviceEnvironmentName, + (JSON..=) "State" Prelude.<$> state, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "CapacityLimits" ServiceEnvironment where + type PropertyType "CapacityLimits" ServiceEnvironment = [CapacityLimitProperty] + set newValue ServiceEnvironment {..} + = ServiceEnvironment {capacityLimits = newValue, ..} +instance Property "ServiceEnvironmentName" ServiceEnvironment where + type PropertyType "ServiceEnvironmentName" ServiceEnvironment = Value Prelude.Text + set newValue ServiceEnvironment {..} + = ServiceEnvironment + {serviceEnvironmentName = Prelude.pure newValue, ..} +instance Property "ServiceEnvironmentType" ServiceEnvironment where + type PropertyType "ServiceEnvironmentType" ServiceEnvironment = Value Prelude.Text + set newValue ServiceEnvironment {..} + = ServiceEnvironment {serviceEnvironmentType = newValue, ..} +instance Property "State" ServiceEnvironment where + type PropertyType "State" ServiceEnvironment = Value Prelude.Text + set newValue ServiceEnvironment {..} + = ServiceEnvironment {state = Prelude.pure newValue, ..} +instance Property "Tags" ServiceEnvironment where + type PropertyType "Tags" ServiceEnvironment = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue ServiceEnvironment {..} + = ServiceEnvironment {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ServiceEnvironment/CapacityLimitProperty.hs b/gen/Stratosphere/Batch/ServiceEnvironment/CapacityLimitProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ServiceEnvironment/CapacityLimitProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.Batch.ServiceEnvironment.CapacityLimitProperty ( + CapacityLimitProperty(..), mkCapacityLimitProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data CapacityLimitProperty + = -- | See: + CapacityLimitProperty {haddock_workaround_ :: (), + -- | See: + capacityUnit :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + maxCapacity :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkCapacityLimitProperty :: CapacityLimitProperty +mkCapacityLimitProperty + = CapacityLimitProperty + {haddock_workaround_ = (), capacityUnit = Prelude.Nothing, + maxCapacity = Prelude.Nothing} +instance ToResourceProperties CapacityLimitProperty where + toResourceProperties CapacityLimitProperty {..} + = ResourceProperties + {awsType = "AWS::Batch::ServiceEnvironment.CapacityLimit", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CapacityUnit" Prelude.<$> capacityUnit, + (JSON..=) "MaxCapacity" Prelude.<$> maxCapacity])} +instance JSON.ToJSON CapacityLimitProperty where + toJSON CapacityLimitProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CapacityUnit" Prelude.<$> capacityUnit, + (JSON..=) "MaxCapacity" Prelude.<$> maxCapacity])) +instance Property "CapacityUnit" CapacityLimitProperty where + type PropertyType "CapacityUnit" CapacityLimitProperty = Value Prelude.Text + set newValue CapacityLimitProperty {..} + = CapacityLimitProperty {capacityUnit = Prelude.pure newValue, ..} +instance Property "MaxCapacity" CapacityLimitProperty where + type PropertyType "MaxCapacity" CapacityLimitProperty = Value Prelude.Integer + set newValue CapacityLimitProperty {..} + = CapacityLimitProperty {maxCapacity = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/Batch/ServiceEnvironment/CapacityLimitProperty.hs-boot b/gen/Stratosphere/Batch/ServiceEnvironment/CapacityLimitProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/Batch/ServiceEnvironment/CapacityLimitProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.Batch.ServiceEnvironment.CapacityLimitProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data CapacityLimitProperty :: Prelude.Type +instance ToResourceProperties CapacityLimitProperty +instance Prelude.Eq CapacityLimitProperty +instance Prelude.Show CapacityLimitProperty +instance JSON.ToJSON CapacityLimitProperty diff --git a/stratosphere-batch.cabal b/stratosphere-batch.cabal new file mode 100644 --- /dev/null +++ b/stratosphere-batch.cabal @@ -0,0 +1,139 @@ +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-batch +version: 1.0.0 +synopsis: Stratosphere integration for AWS Batch. +description: Integration into stratosphere to generate resources and properties for AWS Batch +category: AWS, Cloud, Batch +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.Batch.ComputeEnvironment + Stratosphere.Batch.ComputeEnvironment.ComputeResourcesProperty + Stratosphere.Batch.ComputeEnvironment.Ec2ConfigurationObjectProperty + Stratosphere.Batch.ComputeEnvironment.EksConfigurationProperty + Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationOverrideProperty + Stratosphere.Batch.ComputeEnvironment.LaunchTemplateSpecificationProperty + Stratosphere.Batch.ComputeEnvironment.UpdatePolicyProperty + Stratosphere.Batch.ConsumableResource + Stratosphere.Batch.JobDefinition + Stratosphere.Batch.JobDefinition.ConsumableResourcePropertiesProperty + Stratosphere.Batch.JobDefinition.ConsumableResourceRequirementProperty + Stratosphere.Batch.JobDefinition.ContainerPropertiesProperty + Stratosphere.Batch.JobDefinition.DeviceProperty + Stratosphere.Batch.JobDefinition.EcsPropertiesProperty + Stratosphere.Batch.JobDefinition.EcsTaskPropertiesProperty + Stratosphere.Batch.JobDefinition.EFSAuthorizationConfigProperty + Stratosphere.Batch.JobDefinition.EFSVolumeConfigurationProperty + Stratosphere.Batch.JobDefinition.EksContainerEnvironmentVariableProperty + Stratosphere.Batch.JobDefinition.EksContainerProperty + Stratosphere.Batch.JobDefinition.EksContainerResourceRequirementsProperty + Stratosphere.Batch.JobDefinition.EksContainerSecurityContextProperty + Stratosphere.Batch.JobDefinition.EksContainerVolumeMountProperty + Stratosphere.Batch.JobDefinition.EksEmptyDirProperty + Stratosphere.Batch.JobDefinition.EksHostPathProperty + Stratosphere.Batch.JobDefinition.EksMetadataProperty + Stratosphere.Batch.JobDefinition.EksPersistentVolumeClaimProperty + Stratosphere.Batch.JobDefinition.EksPodPropertiesProperty + Stratosphere.Batch.JobDefinition.EksPropertiesProperty + Stratosphere.Batch.JobDefinition.EksSecretProperty + Stratosphere.Batch.JobDefinition.EksVolumeProperty + Stratosphere.Batch.JobDefinition.EnvironmentProperty + Stratosphere.Batch.JobDefinition.EphemeralStorageProperty + Stratosphere.Batch.JobDefinition.EvaluateOnExitProperty + Stratosphere.Batch.JobDefinition.FargatePlatformConfigurationProperty + Stratosphere.Batch.JobDefinition.FirelensConfigurationProperty + Stratosphere.Batch.JobDefinition.HostProperty + Stratosphere.Batch.JobDefinition.ImagePullSecretProperty + Stratosphere.Batch.JobDefinition.JobTimeoutProperty + Stratosphere.Batch.JobDefinition.LinuxParametersProperty + Stratosphere.Batch.JobDefinition.LogConfigurationProperty + Stratosphere.Batch.JobDefinition.MountPointProperty + Stratosphere.Batch.JobDefinition.MultiNodeContainerPropertiesProperty + Stratosphere.Batch.JobDefinition.MultiNodeEcsPropertiesProperty + Stratosphere.Batch.JobDefinition.MultiNodeEcsTaskPropertiesProperty + Stratosphere.Batch.JobDefinition.NetworkConfigurationProperty + Stratosphere.Batch.JobDefinition.NodePropertiesProperty + Stratosphere.Batch.JobDefinition.NodeRangePropertyProperty + Stratosphere.Batch.JobDefinition.RepositoryCredentialsProperty + Stratosphere.Batch.JobDefinition.ResourceRequirementProperty + Stratosphere.Batch.JobDefinition.ResourceRetentionPolicyProperty + Stratosphere.Batch.JobDefinition.RetryStrategyProperty + Stratosphere.Batch.JobDefinition.RuntimePlatformProperty + Stratosphere.Batch.JobDefinition.SecretProperty + Stratosphere.Batch.JobDefinition.TaskContainerDependencyProperty + Stratosphere.Batch.JobDefinition.TaskContainerPropertiesProperty + Stratosphere.Batch.JobDefinition.TmpfsProperty + Stratosphere.Batch.JobDefinition.UlimitProperty + Stratosphere.Batch.JobDefinition.VolumeProperty + Stratosphere.Batch.JobQueue + Stratosphere.Batch.JobQueue.ComputeEnvironmentOrderProperty + Stratosphere.Batch.JobQueue.JobStateTimeLimitActionProperty + Stratosphere.Batch.JobQueue.ServiceEnvironmentOrderProperty + Stratosphere.Batch.SchedulingPolicy + Stratosphere.Batch.SchedulingPolicy.FairsharePolicyProperty + Stratosphere.Batch.SchedulingPolicy.ShareAttributesProperty + Stratosphere.Batch.ServiceEnvironment + Stratosphere.Batch.ServiceEnvironment.CapacityLimitProperty + other-modules: + Paths_stratosphere_batch + 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