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/CloudFormation/CustomResource.hs b/gen/Stratosphere/CloudFormation/CustomResource.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/CustomResource.hs @@ -0,0 +1,47 @@ +module Stratosphere.CloudFormation.CustomResource ( + CustomResource(..), mkCustomResource + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data CustomResource + = -- | See: + CustomResource {haddock_workaround_ :: (), + -- | See: + serviceTimeout :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + serviceToken :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkCustomResource :: Value Prelude.Text -> CustomResource +mkCustomResource serviceToken + = CustomResource + {haddock_workaround_ = (), serviceToken = serviceToken, + serviceTimeout = Prelude.Nothing} +instance ToResourceProperties CustomResource where + toResourceProperties CustomResource {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::CustomResource", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ServiceToken" JSON..= serviceToken] + (Prelude.catMaybes + [(JSON..=) "ServiceTimeout" Prelude.<$> serviceTimeout]))} +instance JSON.ToJSON CustomResource where + toJSON CustomResource {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ServiceToken" JSON..= serviceToken] + (Prelude.catMaybes + [(JSON..=) "ServiceTimeout" Prelude.<$> serviceTimeout]))) +instance Property "ServiceTimeout" CustomResource where + type PropertyType "ServiceTimeout" CustomResource = Value Prelude.Integer + set newValue CustomResource {..} + = CustomResource {serviceTimeout = Prelude.pure newValue, ..} +instance Property "ServiceToken" CustomResource where + type PropertyType "ServiceToken" CustomResource = Value Prelude.Text + set newValue CustomResource {..} + = CustomResource {serviceToken = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook.hs b/gen/Stratosphere/CloudFormation/GuardHook.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook.hs @@ -0,0 +1,124 @@ +module Stratosphere.CloudFormation.GuardHook ( + module Exports, GuardHook(..), mkGuardHook + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.OptionsProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.S3LocationProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.StackFiltersProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.TargetFiltersProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data GuardHook + = -- | See: + GuardHook {haddock_workaround_ :: (), + -- | See: + alias :: (Value Prelude.Text), + -- | See: + executionRole :: (Value Prelude.Text), + -- | See: + failureMode :: (Value Prelude.Text), + -- | See: + hookStatus :: (Value Prelude.Text), + -- | See: + logBucket :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + options :: (Prelude.Maybe OptionsProperty), + -- | See: + ruleLocation :: S3LocationProperty, + -- | See: + stackFilters :: (Prelude.Maybe StackFiltersProperty), + -- | See: + targetFilters :: (Prelude.Maybe TargetFiltersProperty), + -- | See: + targetOperations :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkGuardHook :: + Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text + -> S3LocationProperty -> ValueList Prelude.Text -> GuardHook +mkGuardHook + alias + executionRole + failureMode + hookStatus + ruleLocation + targetOperations + = GuardHook + {haddock_workaround_ = (), alias = alias, + executionRole = executionRole, failureMode = failureMode, + hookStatus = hookStatus, ruleLocation = ruleLocation, + targetOperations = targetOperations, logBucket = Prelude.Nothing, + options = Prelude.Nothing, stackFilters = Prelude.Nothing, + targetFilters = Prelude.Nothing} +instance ToResourceProperties GuardHook where + toResourceProperties GuardHook {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Alias" JSON..= alias, "ExecutionRole" JSON..= executionRole, + "FailureMode" JSON..= failureMode, "HookStatus" JSON..= hookStatus, + "RuleLocation" JSON..= ruleLocation, + "TargetOperations" JSON..= targetOperations] + (Prelude.catMaybes + [(JSON..=) "LogBucket" Prelude.<$> logBucket, + (JSON..=) "Options" Prelude.<$> options, + (JSON..=) "StackFilters" Prelude.<$> stackFilters, + (JSON..=) "TargetFilters" Prelude.<$> targetFilters]))} +instance JSON.ToJSON GuardHook where + toJSON GuardHook {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Alias" JSON..= alias, "ExecutionRole" JSON..= executionRole, + "FailureMode" JSON..= failureMode, "HookStatus" JSON..= hookStatus, + "RuleLocation" JSON..= ruleLocation, + "TargetOperations" JSON..= targetOperations] + (Prelude.catMaybes + [(JSON..=) "LogBucket" Prelude.<$> logBucket, + (JSON..=) "Options" Prelude.<$> options, + (JSON..=) "StackFilters" Prelude.<$> stackFilters, + (JSON..=) "TargetFilters" Prelude.<$> targetFilters]))) +instance Property "Alias" GuardHook where + type PropertyType "Alias" GuardHook = Value Prelude.Text + set newValue GuardHook {..} = GuardHook {alias = newValue, ..} +instance Property "ExecutionRole" GuardHook where + type PropertyType "ExecutionRole" GuardHook = Value Prelude.Text + set newValue GuardHook {..} + = GuardHook {executionRole = newValue, ..} +instance Property "FailureMode" GuardHook where + type PropertyType "FailureMode" GuardHook = Value Prelude.Text + set newValue GuardHook {..} + = GuardHook {failureMode = newValue, ..} +instance Property "HookStatus" GuardHook where + type PropertyType "HookStatus" GuardHook = Value Prelude.Text + set newValue GuardHook {..} = GuardHook {hookStatus = newValue, ..} +instance Property "LogBucket" GuardHook where + type PropertyType "LogBucket" GuardHook = Value Prelude.Text + set newValue GuardHook {..} + = GuardHook {logBucket = Prelude.pure newValue, ..} +instance Property "Options" GuardHook where + type PropertyType "Options" GuardHook = OptionsProperty + set newValue GuardHook {..} + = GuardHook {options = Prelude.pure newValue, ..} +instance Property "RuleLocation" GuardHook where + type PropertyType "RuleLocation" GuardHook = S3LocationProperty + set newValue GuardHook {..} + = GuardHook {ruleLocation = newValue, ..} +instance Property "StackFilters" GuardHook where + type PropertyType "StackFilters" GuardHook = StackFiltersProperty + set newValue GuardHook {..} + = GuardHook {stackFilters = Prelude.pure newValue, ..} +instance Property "TargetFilters" GuardHook where + type PropertyType "TargetFilters" GuardHook = TargetFiltersProperty + set newValue GuardHook {..} + = GuardHook {targetFilters = Prelude.pure newValue, ..} +instance Property "TargetOperations" GuardHook where + type PropertyType "TargetOperations" GuardHook = ValueList Prelude.Text + set newValue GuardHook {..} + = GuardHook {targetOperations = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/HookTargetProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/HookTargetProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/HookTargetProperty.hs @@ -0,0 +1,51 @@ +module Stratosphere.CloudFormation.GuardHook.HookTargetProperty ( + HookTargetProperty(..), mkHookTargetProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HookTargetProperty + = -- | See: + HookTargetProperty {haddock_workaround_ :: (), + -- | See: + action :: (Value Prelude.Text), + -- | See: + invocationPoint :: (Value Prelude.Text), + -- | See: + targetName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkHookTargetProperty :: + Value Prelude.Text + -> Value Prelude.Text -> Value Prelude.Text -> HookTargetProperty +mkHookTargetProperty action invocationPoint targetName + = HookTargetProperty + {haddock_workaround_ = (), action = action, + invocationPoint = invocationPoint, targetName = targetName} +instance ToResourceProperties HookTargetProperty where + toResourceProperties HookTargetProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.HookTarget", + supportsTags = Prelude.False, + properties = ["Action" JSON..= action, + "InvocationPoint" JSON..= invocationPoint, + "TargetName" JSON..= targetName]} +instance JSON.ToJSON HookTargetProperty where + toJSON HookTargetProperty {..} + = JSON.object + ["Action" JSON..= action, + "InvocationPoint" JSON..= invocationPoint, + "TargetName" JSON..= targetName] +instance Property "Action" HookTargetProperty where + type PropertyType "Action" HookTargetProperty = Value Prelude.Text + set newValue HookTargetProperty {..} + = HookTargetProperty {action = newValue, ..} +instance Property "InvocationPoint" HookTargetProperty where + type PropertyType "InvocationPoint" HookTargetProperty = Value Prelude.Text + set newValue HookTargetProperty {..} + = HookTargetProperty {invocationPoint = newValue, ..} +instance Property "TargetName" HookTargetProperty where + type PropertyType "TargetName" HookTargetProperty = Value Prelude.Text + set newValue HookTargetProperty {..} + = HookTargetProperty {targetName = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/HookTargetProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/HookTargetProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/HookTargetProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.HookTargetProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data HookTargetProperty :: Prelude.Type +instance ToResourceProperties HookTargetProperty +instance Prelude.Eq HookTargetProperty +instance Prelude.Show HookTargetProperty +instance JSON.ToJSON HookTargetProperty diff --git a/gen/Stratosphere/CloudFormation/GuardHook/OptionsProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/OptionsProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/OptionsProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.CloudFormation.GuardHook.OptionsProperty ( + module Exports, OptionsProperty(..), mkOptionsProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.S3LocationProperty as Exports +import Stratosphere.ResourceProperties +data OptionsProperty + = -- | See: + OptionsProperty {haddock_workaround_ :: (), + -- | See: + inputParams :: (Prelude.Maybe S3LocationProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkOptionsProperty :: OptionsProperty +mkOptionsProperty + = OptionsProperty + {haddock_workaround_ = (), inputParams = Prelude.Nothing} +instance ToResourceProperties OptionsProperty where + toResourceProperties OptionsProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.Options", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "InputParams" Prelude.<$> inputParams])} +instance JSON.ToJSON OptionsProperty where + toJSON OptionsProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "InputParams" Prelude.<$> inputParams])) +instance Property "InputParams" OptionsProperty where + type PropertyType "InputParams" OptionsProperty = S3LocationProperty + set newValue OptionsProperty {..} + = OptionsProperty {inputParams = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/OptionsProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/OptionsProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/OptionsProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.OptionsProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data OptionsProperty :: Prelude.Type +instance ToResourceProperties OptionsProperty +instance Prelude.Eq OptionsProperty +instance Prelude.Show OptionsProperty +instance JSON.ToJSON OptionsProperty diff --git a/gen/Stratosphere/CloudFormation/GuardHook/S3LocationProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/S3LocationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/S3LocationProperty.hs @@ -0,0 +1,44 @@ +module Stratosphere.CloudFormation.GuardHook.S3LocationProperty ( + S3LocationProperty(..), mkS3LocationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data S3LocationProperty + = -- | See: + S3LocationProperty {haddock_workaround_ :: (), + -- | See: + uri :: (Value Prelude.Text), + -- | See: + versionId :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkS3LocationProperty :: Value Prelude.Text -> S3LocationProperty +mkS3LocationProperty uri + = S3LocationProperty + {haddock_workaround_ = (), uri = uri, versionId = Prelude.Nothing} +instance ToResourceProperties S3LocationProperty where + toResourceProperties S3LocationProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.S3Location", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Uri" JSON..= uri] + (Prelude.catMaybes [(JSON..=) "VersionId" Prelude.<$> versionId]))} +instance JSON.ToJSON S3LocationProperty where + toJSON S3LocationProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Uri" JSON..= uri] + (Prelude.catMaybes [(JSON..=) "VersionId" Prelude.<$> versionId]))) +instance Property "Uri" S3LocationProperty where + type PropertyType "Uri" S3LocationProperty = Value Prelude.Text + set newValue S3LocationProperty {..} + = S3LocationProperty {uri = newValue, ..} +instance Property "VersionId" S3LocationProperty where + type PropertyType "VersionId" S3LocationProperty = Value Prelude.Text + set newValue S3LocationProperty {..} + = S3LocationProperty {versionId = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/S3LocationProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/S3LocationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/S3LocationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.S3LocationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data S3LocationProperty :: Prelude.Type +instance ToResourceProperties S3LocationProperty +instance Prelude.Eq S3LocationProperty +instance Prelude.Show S3LocationProperty +instance JSON.ToJSON S3LocationProperty diff --git a/gen/Stratosphere/CloudFormation/GuardHook/StackFiltersProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/StackFiltersProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/StackFiltersProperty.hs @@ -0,0 +1,58 @@ +module Stratosphere.CloudFormation.GuardHook.StackFiltersProperty ( + module Exports, StackFiltersProperty(..), mkStackFiltersProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.StackNamesProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.StackRolesProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackFiltersProperty + = -- | See: + StackFiltersProperty {haddock_workaround_ :: (), + -- | See: + filteringCriteria :: (Value Prelude.Text), + -- | See: + stackNames :: (Prelude.Maybe StackNamesProperty), + -- | See: + stackRoles :: (Prelude.Maybe StackRolesProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackFiltersProperty :: + Value Prelude.Text -> StackFiltersProperty +mkStackFiltersProperty filteringCriteria + = StackFiltersProperty + {haddock_workaround_ = (), filteringCriteria = filteringCriteria, + stackNames = Prelude.Nothing, stackRoles = Prelude.Nothing} +instance ToResourceProperties StackFiltersProperty where + toResourceProperties StackFiltersProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.StackFilters", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["FilteringCriteria" JSON..= filteringCriteria] + (Prelude.catMaybes + [(JSON..=) "StackNames" Prelude.<$> stackNames, + (JSON..=) "StackRoles" Prelude.<$> stackRoles]))} +instance JSON.ToJSON StackFiltersProperty where + toJSON StackFiltersProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["FilteringCriteria" JSON..= filteringCriteria] + (Prelude.catMaybes + [(JSON..=) "StackNames" Prelude.<$> stackNames, + (JSON..=) "StackRoles" Prelude.<$> stackRoles]))) +instance Property "FilteringCriteria" StackFiltersProperty where + type PropertyType "FilteringCriteria" StackFiltersProperty = Value Prelude.Text + set newValue StackFiltersProperty {..} + = StackFiltersProperty {filteringCriteria = newValue, ..} +instance Property "StackNames" StackFiltersProperty where + type PropertyType "StackNames" StackFiltersProperty = StackNamesProperty + set newValue StackFiltersProperty {..} + = StackFiltersProperty {stackNames = Prelude.pure newValue, ..} +instance Property "StackRoles" StackFiltersProperty where + type PropertyType "StackRoles" StackFiltersProperty = StackRolesProperty + set newValue StackFiltersProperty {..} + = StackFiltersProperty {stackRoles = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/StackFiltersProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/StackFiltersProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/StackFiltersProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.StackFiltersProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackFiltersProperty :: Prelude.Type +instance ToResourceProperties StackFiltersProperty +instance Prelude.Eq StackFiltersProperty +instance Prelude.Show StackFiltersProperty +instance JSON.ToJSON StackFiltersProperty diff --git a/gen/Stratosphere/CloudFormation/GuardHook/StackNamesProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/StackNamesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/StackNamesProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.GuardHook.StackNamesProperty ( + StackNamesProperty(..), mkStackNamesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackNamesProperty + = -- | See: + StackNamesProperty {haddock_workaround_ :: (), + -- | See: + exclude :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + include :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackNamesProperty :: StackNamesProperty +mkStackNamesProperty + = StackNamesProperty + {haddock_workaround_ = (), exclude = Prelude.Nothing, + include = Prelude.Nothing} +instance ToResourceProperties StackNamesProperty where + toResourceProperties StackNamesProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.StackNames", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])} +instance JSON.ToJSON StackNamesProperty where + toJSON StackNamesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])) +instance Property "Exclude" StackNamesProperty where + type PropertyType "Exclude" StackNamesProperty = ValueList Prelude.Text + set newValue StackNamesProperty {..} + = StackNamesProperty {exclude = Prelude.pure newValue, ..} +instance Property "Include" StackNamesProperty where + type PropertyType "Include" StackNamesProperty = ValueList Prelude.Text + set newValue StackNamesProperty {..} + = StackNamesProperty {include = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/StackNamesProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/StackNamesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/StackNamesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.StackNamesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackNamesProperty :: Prelude.Type +instance ToResourceProperties StackNamesProperty +instance Prelude.Eq StackNamesProperty +instance Prelude.Show StackNamesProperty +instance JSON.ToJSON StackNamesProperty diff --git a/gen/Stratosphere/CloudFormation/GuardHook/StackRolesProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/StackRolesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/StackRolesProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.GuardHook.StackRolesProperty ( + StackRolesProperty(..), mkStackRolesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackRolesProperty + = -- | See: + StackRolesProperty {haddock_workaround_ :: (), + -- | See: + exclude :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + include :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackRolesProperty :: StackRolesProperty +mkStackRolesProperty + = StackRolesProperty + {haddock_workaround_ = (), exclude = Prelude.Nothing, + include = Prelude.Nothing} +instance ToResourceProperties StackRolesProperty where + toResourceProperties StackRolesProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.StackRoles", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])} +instance JSON.ToJSON StackRolesProperty where + toJSON StackRolesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])) +instance Property "Exclude" StackRolesProperty where + type PropertyType "Exclude" StackRolesProperty = ValueList Prelude.Text + set newValue StackRolesProperty {..} + = StackRolesProperty {exclude = Prelude.pure newValue, ..} +instance Property "Include" StackRolesProperty where + type PropertyType "Include" StackRolesProperty = ValueList Prelude.Text + set newValue StackRolesProperty {..} + = StackRolesProperty {include = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/StackRolesProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/StackRolesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/StackRolesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.StackRolesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackRolesProperty :: Prelude.Type +instance ToResourceProperties StackRolesProperty +instance Prelude.Eq StackRolesProperty +instance Prelude.Show StackRolesProperty +instance JSON.ToJSON StackRolesProperty diff --git a/gen/Stratosphere/CloudFormation/GuardHook/TargetFiltersProperty.hs b/gen/Stratosphere/CloudFormation/GuardHook/TargetFiltersProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/TargetFiltersProperty.hs @@ -0,0 +1,64 @@ +module Stratosphere.CloudFormation.GuardHook.TargetFiltersProperty ( + module Exports, TargetFiltersProperty(..), mkTargetFiltersProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.GuardHook.HookTargetProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TargetFiltersProperty + = -- | See: + TargetFiltersProperty {haddock_workaround_ :: (), + -- | See: + actions :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + invocationPoints :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + targetNames :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + targets :: (Prelude.Maybe [HookTargetProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkTargetFiltersProperty :: TargetFiltersProperty +mkTargetFiltersProperty + = TargetFiltersProperty + {haddock_workaround_ = (), actions = Prelude.Nothing, + invocationPoints = Prelude.Nothing, targetNames = Prelude.Nothing, + targets = Prelude.Nothing} +instance ToResourceProperties TargetFiltersProperty where + toResourceProperties TargetFiltersProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::GuardHook.TargetFilters", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Actions" Prelude.<$> actions, + (JSON..=) "InvocationPoints" Prelude.<$> invocationPoints, + (JSON..=) "TargetNames" Prelude.<$> targetNames, + (JSON..=) "Targets" Prelude.<$> targets])} +instance JSON.ToJSON TargetFiltersProperty where + toJSON TargetFiltersProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Actions" Prelude.<$> actions, + (JSON..=) "InvocationPoints" Prelude.<$> invocationPoints, + (JSON..=) "TargetNames" Prelude.<$> targetNames, + (JSON..=) "Targets" Prelude.<$> targets])) +instance Property "Actions" TargetFiltersProperty where + type PropertyType "Actions" TargetFiltersProperty = ValueList Prelude.Text + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty {actions = Prelude.pure newValue, ..} +instance Property "InvocationPoints" TargetFiltersProperty where + type PropertyType "InvocationPoints" TargetFiltersProperty = ValueList Prelude.Text + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty + {invocationPoints = Prelude.pure newValue, ..} +instance Property "TargetNames" TargetFiltersProperty where + type PropertyType "TargetNames" TargetFiltersProperty = ValueList Prelude.Text + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty {targetNames = Prelude.pure newValue, ..} +instance Property "Targets" TargetFiltersProperty where + type PropertyType "Targets" TargetFiltersProperty = [HookTargetProperty] + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty {targets = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/GuardHook/TargetFiltersProperty.hs-boot b/gen/Stratosphere/CloudFormation/GuardHook/TargetFiltersProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/GuardHook/TargetFiltersProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.GuardHook.TargetFiltersProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data TargetFiltersProperty :: Prelude.Type +instance ToResourceProperties TargetFiltersProperty +instance Prelude.Eq TargetFiltersProperty +instance Prelude.Show TargetFiltersProperty +instance JSON.ToJSON TargetFiltersProperty diff --git a/gen/Stratosphere/CloudFormation/HookDefaultVersion.hs b/gen/Stratosphere/CloudFormation/HookDefaultVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/HookDefaultVersion.hs @@ -0,0 +1,53 @@ +module Stratosphere.CloudFormation.HookDefaultVersion ( + HookDefaultVersion(..), mkHookDefaultVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HookDefaultVersion + = -- | See: + HookDefaultVersion {haddock_workaround_ :: (), + -- | See: + typeName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeVersionArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + versionId :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkHookDefaultVersion :: HookDefaultVersion +mkHookDefaultVersion + = HookDefaultVersion + {haddock_workaround_ = (), typeName = Prelude.Nothing, + typeVersionArn = Prelude.Nothing, versionId = Prelude.Nothing} +instance ToResourceProperties HookDefaultVersion where + toResourceProperties HookDefaultVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::HookDefaultVersion", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "TypeName" Prelude.<$> typeName, + (JSON..=) "TypeVersionArn" Prelude.<$> typeVersionArn, + (JSON..=) "VersionId" Prelude.<$> versionId])} +instance JSON.ToJSON HookDefaultVersion where + toJSON HookDefaultVersion {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "TypeName" Prelude.<$> typeName, + (JSON..=) "TypeVersionArn" Prelude.<$> typeVersionArn, + (JSON..=) "VersionId" Prelude.<$> versionId])) +instance Property "TypeName" HookDefaultVersion where + type PropertyType "TypeName" HookDefaultVersion = Value Prelude.Text + set newValue HookDefaultVersion {..} + = HookDefaultVersion {typeName = Prelude.pure newValue, ..} +instance Property "TypeVersionArn" HookDefaultVersion where + type PropertyType "TypeVersionArn" HookDefaultVersion = Value Prelude.Text + set newValue HookDefaultVersion {..} + = HookDefaultVersion {typeVersionArn = Prelude.pure newValue, ..} +instance Property "VersionId" HookDefaultVersion where + type PropertyType "VersionId" HookDefaultVersion = Value Prelude.Text + set newValue HookDefaultVersion {..} + = HookDefaultVersion {versionId = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/HookTypeConfig.hs b/gen/Stratosphere/CloudFormation/HookTypeConfig.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/HookTypeConfig.hs @@ -0,0 +1,64 @@ +module Stratosphere.CloudFormation.HookTypeConfig ( + HookTypeConfig(..), mkHookTypeConfig + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HookTypeConfig + = -- | See: + HookTypeConfig {haddock_workaround_ :: (), + -- | See: + configuration :: (Value Prelude.Text), + -- | See: + configurationAlias :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeName :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkHookTypeConfig :: Value Prelude.Text -> HookTypeConfig +mkHookTypeConfig configuration + = HookTypeConfig + {haddock_workaround_ = (), configuration = configuration, + configurationAlias = Prelude.Nothing, typeArn = Prelude.Nothing, + typeName = Prelude.Nothing} +instance ToResourceProperties HookTypeConfig where + toResourceProperties HookTypeConfig {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::HookTypeConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Configuration" JSON..= configuration] + (Prelude.catMaybes + [(JSON..=) "ConfigurationAlias" Prelude.<$> configurationAlias, + (JSON..=) "TypeArn" Prelude.<$> typeArn, + (JSON..=) "TypeName" Prelude.<$> typeName]))} +instance JSON.ToJSON HookTypeConfig where + toJSON HookTypeConfig {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Configuration" JSON..= configuration] + (Prelude.catMaybes + [(JSON..=) "ConfigurationAlias" Prelude.<$> configurationAlias, + (JSON..=) "TypeArn" Prelude.<$> typeArn, + (JSON..=) "TypeName" Prelude.<$> typeName]))) +instance Property "Configuration" HookTypeConfig where + type PropertyType "Configuration" HookTypeConfig = Value Prelude.Text + set newValue HookTypeConfig {..} + = HookTypeConfig {configuration = newValue, ..} +instance Property "ConfigurationAlias" HookTypeConfig where + type PropertyType "ConfigurationAlias" HookTypeConfig = Value Prelude.Text + set newValue HookTypeConfig {..} + = HookTypeConfig {configurationAlias = Prelude.pure newValue, ..} +instance Property "TypeArn" HookTypeConfig where + type PropertyType "TypeArn" HookTypeConfig = Value Prelude.Text + set newValue HookTypeConfig {..} + = HookTypeConfig {typeArn = Prelude.pure newValue, ..} +instance Property "TypeName" HookTypeConfig where + type PropertyType "TypeName" HookTypeConfig = Value Prelude.Text + set newValue HookTypeConfig {..} + = HookTypeConfig {typeName = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/HookVersion.hs b/gen/Stratosphere/CloudFormation/HookVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/HookVersion.hs @@ -0,0 +1,67 @@ +module Stratosphere.CloudFormation.HookVersion ( + module Exports, HookVersion(..), mkHookVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.HookVersion.LoggingConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HookVersion + = -- | See: + HookVersion {haddock_workaround_ :: (), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + loggingConfig :: (Prelude.Maybe LoggingConfigProperty), + -- | See: + schemaHandlerPackage :: (Value Prelude.Text), + -- | See: + typeName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkHookVersion :: + Value Prelude.Text -> Value Prelude.Text -> HookVersion +mkHookVersion schemaHandlerPackage typeName + = HookVersion + {haddock_workaround_ = (), + schemaHandlerPackage = schemaHandlerPackage, typeName = typeName, + executionRoleArn = Prelude.Nothing, + loggingConfig = Prelude.Nothing} +instance ToResourceProperties HookVersion where + toResourceProperties HookVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::HookVersion", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["SchemaHandlerPackage" JSON..= schemaHandlerPackage, + "TypeName" JSON..= typeName] + (Prelude.catMaybes + [(JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "LoggingConfig" Prelude.<$> loggingConfig]))} +instance JSON.ToJSON HookVersion where + toJSON HookVersion {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["SchemaHandlerPackage" JSON..= schemaHandlerPackage, + "TypeName" JSON..= typeName] + (Prelude.catMaybes + [(JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "LoggingConfig" Prelude.<$> loggingConfig]))) +instance Property "ExecutionRoleArn" HookVersion where + type PropertyType "ExecutionRoleArn" HookVersion = Value Prelude.Text + set newValue HookVersion {..} + = HookVersion {executionRoleArn = Prelude.pure newValue, ..} +instance Property "LoggingConfig" HookVersion where + type PropertyType "LoggingConfig" HookVersion = LoggingConfigProperty + set newValue HookVersion {..} + = HookVersion {loggingConfig = Prelude.pure newValue, ..} +instance Property "SchemaHandlerPackage" HookVersion where + type PropertyType "SchemaHandlerPackage" HookVersion = Value Prelude.Text + set newValue HookVersion {..} + = HookVersion {schemaHandlerPackage = newValue, ..} +instance Property "TypeName" HookVersion where + type PropertyType "TypeName" HookVersion = Value Prelude.Text + set newValue HookVersion {..} + = HookVersion {typeName = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/HookVersion/LoggingConfigProperty.hs b/gen/Stratosphere/CloudFormation/HookVersion/LoggingConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/HookVersion/LoggingConfigProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.HookVersion.LoggingConfigProperty ( + LoggingConfigProperty(..), mkLoggingConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LoggingConfigProperty + = -- | See: + LoggingConfigProperty {haddock_workaround_ :: (), + -- | See: + logGroupName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + logRoleArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingConfigProperty :: LoggingConfigProperty +mkLoggingConfigProperty + = LoggingConfigProperty + {haddock_workaround_ = (), logGroupName = Prelude.Nothing, + logRoleArn = Prelude.Nothing} +instance ToResourceProperties LoggingConfigProperty where + toResourceProperties LoggingConfigProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::HookVersion.LoggingConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleArn" Prelude.<$> logRoleArn])} +instance JSON.ToJSON LoggingConfigProperty where + toJSON LoggingConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleArn" Prelude.<$> logRoleArn])) +instance Property "LogGroupName" LoggingConfigProperty where + type PropertyType "LogGroupName" LoggingConfigProperty = Value Prelude.Text + set newValue LoggingConfigProperty {..} + = LoggingConfigProperty {logGroupName = Prelude.pure newValue, ..} +instance Property "LogRoleArn" LoggingConfigProperty where + type PropertyType "LogRoleArn" LoggingConfigProperty = Value Prelude.Text + set newValue LoggingConfigProperty {..} + = LoggingConfigProperty {logRoleArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/HookVersion/LoggingConfigProperty.hs-boot b/gen/Stratosphere/CloudFormation/HookVersion/LoggingConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/HookVersion/LoggingConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.HookVersion.LoggingConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingConfigProperty :: Prelude.Type +instance ToResourceProperties LoggingConfigProperty +instance Prelude.Eq LoggingConfigProperty +instance Prelude.Show LoggingConfigProperty +instance JSON.ToJSON LoggingConfigProperty diff --git a/gen/Stratosphere/CloudFormation/LambdaHook.hs b/gen/Stratosphere/CloudFormation/LambdaHook.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook.hs @@ -0,0 +1,106 @@ +module Stratosphere.CloudFormation.LambdaHook ( + module Exports, LambdaHook(..), mkLambdaHook + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.LambdaHook.StackFiltersProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.LambdaHook.TargetFiltersProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LambdaHook + = -- | See: + LambdaHook {haddock_workaround_ :: (), + -- | See: + alias :: (Value Prelude.Text), + -- | See: + executionRole :: (Value Prelude.Text), + -- | See: + failureMode :: (Value Prelude.Text), + -- | See: + hookStatus :: (Value Prelude.Text), + -- | See: + lambdaFunction :: (Value Prelude.Text), + -- | See: + stackFilters :: (Prelude.Maybe StackFiltersProperty), + -- | See: + targetFilters :: (Prelude.Maybe TargetFiltersProperty), + -- | See: + targetOperations :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkLambdaHook :: + Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text -> ValueList Prelude.Text -> LambdaHook +mkLambdaHook + alias + executionRole + failureMode + hookStatus + lambdaFunction + targetOperations + = LambdaHook + {haddock_workaround_ = (), alias = alias, + executionRole = executionRole, failureMode = failureMode, + hookStatus = hookStatus, lambdaFunction = lambdaFunction, + targetOperations = targetOperations, + stackFilters = Prelude.Nothing, targetFilters = Prelude.Nothing} +instance ToResourceProperties LambdaHook where + toResourceProperties LambdaHook {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::LambdaHook", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Alias" JSON..= alias, "ExecutionRole" JSON..= executionRole, + "FailureMode" JSON..= failureMode, "HookStatus" JSON..= hookStatus, + "LambdaFunction" JSON..= lambdaFunction, + "TargetOperations" JSON..= targetOperations] + (Prelude.catMaybes + [(JSON..=) "StackFilters" Prelude.<$> stackFilters, + (JSON..=) "TargetFilters" Prelude.<$> targetFilters]))} +instance JSON.ToJSON LambdaHook where + toJSON LambdaHook {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Alias" JSON..= alias, "ExecutionRole" JSON..= executionRole, + "FailureMode" JSON..= failureMode, "HookStatus" JSON..= hookStatus, + "LambdaFunction" JSON..= lambdaFunction, + "TargetOperations" JSON..= targetOperations] + (Prelude.catMaybes + [(JSON..=) "StackFilters" Prelude.<$> stackFilters, + (JSON..=) "TargetFilters" Prelude.<$> targetFilters]))) +instance Property "Alias" LambdaHook where + type PropertyType "Alias" LambdaHook = Value Prelude.Text + set newValue LambdaHook {..} = LambdaHook {alias = newValue, ..} +instance Property "ExecutionRole" LambdaHook where + type PropertyType "ExecutionRole" LambdaHook = Value Prelude.Text + set newValue LambdaHook {..} + = LambdaHook {executionRole = newValue, ..} +instance Property "FailureMode" LambdaHook where + type PropertyType "FailureMode" LambdaHook = Value Prelude.Text + set newValue LambdaHook {..} + = LambdaHook {failureMode = newValue, ..} +instance Property "HookStatus" LambdaHook where + type PropertyType "HookStatus" LambdaHook = Value Prelude.Text + set newValue LambdaHook {..} + = LambdaHook {hookStatus = newValue, ..} +instance Property "LambdaFunction" LambdaHook where + type PropertyType "LambdaFunction" LambdaHook = Value Prelude.Text + set newValue LambdaHook {..} + = LambdaHook {lambdaFunction = newValue, ..} +instance Property "StackFilters" LambdaHook where + type PropertyType "StackFilters" LambdaHook = StackFiltersProperty + set newValue LambdaHook {..} + = LambdaHook {stackFilters = Prelude.pure newValue, ..} +instance Property "TargetFilters" LambdaHook where + type PropertyType "TargetFilters" LambdaHook = TargetFiltersProperty + set newValue LambdaHook {..} + = LambdaHook {targetFilters = Prelude.pure newValue, ..} +instance Property "TargetOperations" LambdaHook where + type PropertyType "TargetOperations" LambdaHook = ValueList Prelude.Text + set newValue LambdaHook {..} + = LambdaHook {targetOperations = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/HookTargetProperty.hs b/gen/Stratosphere/CloudFormation/LambdaHook/HookTargetProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/HookTargetProperty.hs @@ -0,0 +1,51 @@ +module Stratosphere.CloudFormation.LambdaHook.HookTargetProperty ( + HookTargetProperty(..), mkHookTargetProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HookTargetProperty + = -- | See: + HookTargetProperty {haddock_workaround_ :: (), + -- | See: + action :: (Value Prelude.Text), + -- | See: + invocationPoint :: (Value Prelude.Text), + -- | See: + targetName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkHookTargetProperty :: + Value Prelude.Text + -> Value Prelude.Text -> Value Prelude.Text -> HookTargetProperty +mkHookTargetProperty action invocationPoint targetName + = HookTargetProperty + {haddock_workaround_ = (), action = action, + invocationPoint = invocationPoint, targetName = targetName} +instance ToResourceProperties HookTargetProperty where + toResourceProperties HookTargetProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::LambdaHook.HookTarget", + supportsTags = Prelude.False, + properties = ["Action" JSON..= action, + "InvocationPoint" JSON..= invocationPoint, + "TargetName" JSON..= targetName]} +instance JSON.ToJSON HookTargetProperty where + toJSON HookTargetProperty {..} + = JSON.object + ["Action" JSON..= action, + "InvocationPoint" JSON..= invocationPoint, + "TargetName" JSON..= targetName] +instance Property "Action" HookTargetProperty where + type PropertyType "Action" HookTargetProperty = Value Prelude.Text + set newValue HookTargetProperty {..} + = HookTargetProperty {action = newValue, ..} +instance Property "InvocationPoint" HookTargetProperty where + type PropertyType "InvocationPoint" HookTargetProperty = Value Prelude.Text + set newValue HookTargetProperty {..} + = HookTargetProperty {invocationPoint = newValue, ..} +instance Property "TargetName" HookTargetProperty where + type PropertyType "TargetName" HookTargetProperty = Value Prelude.Text + set newValue HookTargetProperty {..} + = HookTargetProperty {targetName = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/HookTargetProperty.hs-boot b/gen/Stratosphere/CloudFormation/LambdaHook/HookTargetProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/HookTargetProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.LambdaHook.HookTargetProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data HookTargetProperty :: Prelude.Type +instance ToResourceProperties HookTargetProperty +instance Prelude.Eq HookTargetProperty +instance Prelude.Show HookTargetProperty +instance JSON.ToJSON HookTargetProperty diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/StackFiltersProperty.hs b/gen/Stratosphere/CloudFormation/LambdaHook/StackFiltersProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/StackFiltersProperty.hs @@ -0,0 +1,58 @@ +module Stratosphere.CloudFormation.LambdaHook.StackFiltersProperty ( + module Exports, StackFiltersProperty(..), mkStackFiltersProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.LambdaHook.StackNamesProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.LambdaHook.StackRolesProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackFiltersProperty + = -- | See: + StackFiltersProperty {haddock_workaround_ :: (), + -- | See: + filteringCriteria :: (Value Prelude.Text), + -- | See: + stackNames :: (Prelude.Maybe StackNamesProperty), + -- | See: + stackRoles :: (Prelude.Maybe StackRolesProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackFiltersProperty :: + Value Prelude.Text -> StackFiltersProperty +mkStackFiltersProperty filteringCriteria + = StackFiltersProperty + {haddock_workaround_ = (), filteringCriteria = filteringCriteria, + stackNames = Prelude.Nothing, stackRoles = Prelude.Nothing} +instance ToResourceProperties StackFiltersProperty where + toResourceProperties StackFiltersProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::LambdaHook.StackFilters", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["FilteringCriteria" JSON..= filteringCriteria] + (Prelude.catMaybes + [(JSON..=) "StackNames" Prelude.<$> stackNames, + (JSON..=) "StackRoles" Prelude.<$> stackRoles]))} +instance JSON.ToJSON StackFiltersProperty where + toJSON StackFiltersProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["FilteringCriteria" JSON..= filteringCriteria] + (Prelude.catMaybes + [(JSON..=) "StackNames" Prelude.<$> stackNames, + (JSON..=) "StackRoles" Prelude.<$> stackRoles]))) +instance Property "FilteringCriteria" StackFiltersProperty where + type PropertyType "FilteringCriteria" StackFiltersProperty = Value Prelude.Text + set newValue StackFiltersProperty {..} + = StackFiltersProperty {filteringCriteria = newValue, ..} +instance Property "StackNames" StackFiltersProperty where + type PropertyType "StackNames" StackFiltersProperty = StackNamesProperty + set newValue StackFiltersProperty {..} + = StackFiltersProperty {stackNames = Prelude.pure newValue, ..} +instance Property "StackRoles" StackFiltersProperty where + type PropertyType "StackRoles" StackFiltersProperty = StackRolesProperty + set newValue StackFiltersProperty {..} + = StackFiltersProperty {stackRoles = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/StackFiltersProperty.hs-boot b/gen/Stratosphere/CloudFormation/LambdaHook/StackFiltersProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/StackFiltersProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.LambdaHook.StackFiltersProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackFiltersProperty :: Prelude.Type +instance ToResourceProperties StackFiltersProperty +instance Prelude.Eq StackFiltersProperty +instance Prelude.Show StackFiltersProperty +instance JSON.ToJSON StackFiltersProperty diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/StackNamesProperty.hs b/gen/Stratosphere/CloudFormation/LambdaHook/StackNamesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/StackNamesProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.LambdaHook.StackNamesProperty ( + StackNamesProperty(..), mkStackNamesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackNamesProperty + = -- | See: + StackNamesProperty {haddock_workaround_ :: (), + -- | See: + exclude :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + include :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackNamesProperty :: StackNamesProperty +mkStackNamesProperty + = StackNamesProperty + {haddock_workaround_ = (), exclude = Prelude.Nothing, + include = Prelude.Nothing} +instance ToResourceProperties StackNamesProperty where + toResourceProperties StackNamesProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::LambdaHook.StackNames", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])} +instance JSON.ToJSON StackNamesProperty where + toJSON StackNamesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])) +instance Property "Exclude" StackNamesProperty where + type PropertyType "Exclude" StackNamesProperty = ValueList Prelude.Text + set newValue StackNamesProperty {..} + = StackNamesProperty {exclude = Prelude.pure newValue, ..} +instance Property "Include" StackNamesProperty where + type PropertyType "Include" StackNamesProperty = ValueList Prelude.Text + set newValue StackNamesProperty {..} + = StackNamesProperty {include = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/StackNamesProperty.hs-boot b/gen/Stratosphere/CloudFormation/LambdaHook/StackNamesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/StackNamesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.LambdaHook.StackNamesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackNamesProperty :: Prelude.Type +instance ToResourceProperties StackNamesProperty +instance Prelude.Eq StackNamesProperty +instance Prelude.Show StackNamesProperty +instance JSON.ToJSON StackNamesProperty diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/StackRolesProperty.hs b/gen/Stratosphere/CloudFormation/LambdaHook/StackRolesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/StackRolesProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.LambdaHook.StackRolesProperty ( + StackRolesProperty(..), mkStackRolesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackRolesProperty + = -- | See: + StackRolesProperty {haddock_workaround_ :: (), + -- | See: + exclude :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + include :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackRolesProperty :: StackRolesProperty +mkStackRolesProperty + = StackRolesProperty + {haddock_workaround_ = (), exclude = Prelude.Nothing, + include = Prelude.Nothing} +instance ToResourceProperties StackRolesProperty where + toResourceProperties StackRolesProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::LambdaHook.StackRoles", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])} +instance JSON.ToJSON StackRolesProperty where + toJSON StackRolesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Exclude" Prelude.<$> exclude, + (JSON..=) "Include" Prelude.<$> include])) +instance Property "Exclude" StackRolesProperty where + type PropertyType "Exclude" StackRolesProperty = ValueList Prelude.Text + set newValue StackRolesProperty {..} + = StackRolesProperty {exclude = Prelude.pure newValue, ..} +instance Property "Include" StackRolesProperty where + type PropertyType "Include" StackRolesProperty = ValueList Prelude.Text + set newValue StackRolesProperty {..} + = StackRolesProperty {include = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/StackRolesProperty.hs-boot b/gen/Stratosphere/CloudFormation/LambdaHook/StackRolesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/StackRolesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.LambdaHook.StackRolesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackRolesProperty :: Prelude.Type +instance ToResourceProperties StackRolesProperty +instance Prelude.Eq StackRolesProperty +instance Prelude.Show StackRolesProperty +instance JSON.ToJSON StackRolesProperty diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/TargetFiltersProperty.hs b/gen/Stratosphere/CloudFormation/LambdaHook/TargetFiltersProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/TargetFiltersProperty.hs @@ -0,0 +1,64 @@ +module Stratosphere.CloudFormation.LambdaHook.TargetFiltersProperty ( + module Exports, TargetFiltersProperty(..), mkTargetFiltersProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.LambdaHook.HookTargetProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TargetFiltersProperty + = -- | See: + TargetFiltersProperty {haddock_workaround_ :: (), + -- | See: + actions :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + invocationPoints :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + targetNames :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + targets :: (Prelude.Maybe [HookTargetProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkTargetFiltersProperty :: TargetFiltersProperty +mkTargetFiltersProperty + = TargetFiltersProperty + {haddock_workaround_ = (), actions = Prelude.Nothing, + invocationPoints = Prelude.Nothing, targetNames = Prelude.Nothing, + targets = Prelude.Nothing} +instance ToResourceProperties TargetFiltersProperty where + toResourceProperties TargetFiltersProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::LambdaHook.TargetFilters", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Actions" Prelude.<$> actions, + (JSON..=) "InvocationPoints" Prelude.<$> invocationPoints, + (JSON..=) "TargetNames" Prelude.<$> targetNames, + (JSON..=) "Targets" Prelude.<$> targets])} +instance JSON.ToJSON TargetFiltersProperty where + toJSON TargetFiltersProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Actions" Prelude.<$> actions, + (JSON..=) "InvocationPoints" Prelude.<$> invocationPoints, + (JSON..=) "TargetNames" Prelude.<$> targetNames, + (JSON..=) "Targets" Prelude.<$> targets])) +instance Property "Actions" TargetFiltersProperty where + type PropertyType "Actions" TargetFiltersProperty = ValueList Prelude.Text + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty {actions = Prelude.pure newValue, ..} +instance Property "InvocationPoints" TargetFiltersProperty where + type PropertyType "InvocationPoints" TargetFiltersProperty = ValueList Prelude.Text + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty + {invocationPoints = Prelude.pure newValue, ..} +instance Property "TargetNames" TargetFiltersProperty where + type PropertyType "TargetNames" TargetFiltersProperty = ValueList Prelude.Text + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty {targetNames = Prelude.pure newValue, ..} +instance Property "Targets" TargetFiltersProperty where + type PropertyType "Targets" TargetFiltersProperty = [HookTargetProperty] + set newValue TargetFiltersProperty {..} + = TargetFiltersProperty {targets = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/LambdaHook/TargetFiltersProperty.hs-boot b/gen/Stratosphere/CloudFormation/LambdaHook/TargetFiltersProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/LambdaHook/TargetFiltersProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.LambdaHook.TargetFiltersProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data TargetFiltersProperty :: Prelude.Type +instance ToResourceProperties TargetFiltersProperty +instance Prelude.Eq TargetFiltersProperty +instance Prelude.Show TargetFiltersProperty +instance JSON.ToJSON TargetFiltersProperty diff --git a/gen/Stratosphere/CloudFormation/Macro.hs b/gen/Stratosphere/CloudFormation/Macro.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/Macro.hs @@ -0,0 +1,68 @@ +module Stratosphere.CloudFormation.Macro ( + Macro(..), mkMacro + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data Macro + = -- | See: + Macro {haddock_workaround_ :: (), + -- | See: + description :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + functionName :: (Value Prelude.Text), + -- | See: + logGroupName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + logRoleARN :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + name :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkMacro :: Value Prelude.Text -> Value Prelude.Text -> Macro +mkMacro functionName name + = Macro + {haddock_workaround_ = (), functionName = functionName, + name = name, description = Prelude.Nothing, + logGroupName = Prelude.Nothing, logRoleARN = Prelude.Nothing} +instance ToResourceProperties Macro where + toResourceProperties Macro {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::Macro", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["FunctionName" JSON..= functionName, "Name" JSON..= name] + (Prelude.catMaybes + [(JSON..=) "Description" Prelude.<$> description, + (JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleARN" Prelude.<$> logRoleARN]))} +instance JSON.ToJSON Macro where + toJSON Macro {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["FunctionName" JSON..= functionName, "Name" JSON..= name] + (Prelude.catMaybes + [(JSON..=) "Description" Prelude.<$> description, + (JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleARN" Prelude.<$> logRoleARN]))) +instance Property "Description" Macro where + type PropertyType "Description" Macro = Value Prelude.Text + set newValue Macro {..} + = Macro {description = Prelude.pure newValue, ..} +instance Property "FunctionName" Macro where + type PropertyType "FunctionName" Macro = Value Prelude.Text + set newValue Macro {..} = Macro {functionName = newValue, ..} +instance Property "LogGroupName" Macro where + type PropertyType "LogGroupName" Macro = Value Prelude.Text + set newValue Macro {..} + = Macro {logGroupName = Prelude.pure newValue, ..} +instance Property "LogRoleARN" Macro where + type PropertyType "LogRoleARN" Macro = Value Prelude.Text + set newValue Macro {..} + = Macro {logRoleARN = Prelude.pure newValue, ..} +instance Property "Name" Macro where + type PropertyType "Name" Macro = Value Prelude.Text + set newValue Macro {..} = Macro {name = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/ModuleDefaultVersion.hs b/gen/Stratosphere/CloudFormation/ModuleDefaultVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/ModuleDefaultVersion.hs @@ -0,0 +1,53 @@ +module Stratosphere.CloudFormation.ModuleDefaultVersion ( + ModuleDefaultVersion(..), mkModuleDefaultVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ModuleDefaultVersion + = -- | See: + ModuleDefaultVersion {haddock_workaround_ :: (), + -- | See: + arn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + moduleName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + versionId :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkModuleDefaultVersion :: ModuleDefaultVersion +mkModuleDefaultVersion + = ModuleDefaultVersion + {haddock_workaround_ = (), arn = Prelude.Nothing, + moduleName = Prelude.Nothing, versionId = Prelude.Nothing} +instance ToResourceProperties ModuleDefaultVersion where + toResourceProperties ModuleDefaultVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::ModuleDefaultVersion", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Arn" Prelude.<$> arn, + (JSON..=) "ModuleName" Prelude.<$> moduleName, + (JSON..=) "VersionId" Prelude.<$> versionId])} +instance JSON.ToJSON ModuleDefaultVersion where + toJSON ModuleDefaultVersion {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Arn" Prelude.<$> arn, + (JSON..=) "ModuleName" Prelude.<$> moduleName, + (JSON..=) "VersionId" Prelude.<$> versionId])) +instance Property "Arn" ModuleDefaultVersion where + type PropertyType "Arn" ModuleDefaultVersion = Value Prelude.Text + set newValue ModuleDefaultVersion {..} + = ModuleDefaultVersion {arn = Prelude.pure newValue, ..} +instance Property "ModuleName" ModuleDefaultVersion where + type PropertyType "ModuleName" ModuleDefaultVersion = Value Prelude.Text + set newValue ModuleDefaultVersion {..} + = ModuleDefaultVersion {moduleName = Prelude.pure newValue, ..} +instance Property "VersionId" ModuleDefaultVersion where + type PropertyType "VersionId" ModuleDefaultVersion = Value Prelude.Text + set newValue ModuleDefaultVersion {..} + = ModuleDefaultVersion {versionId = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/ModuleVersion.hs b/gen/Stratosphere/CloudFormation/ModuleVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/ModuleVersion.hs @@ -0,0 +1,42 @@ +module Stratosphere.CloudFormation.ModuleVersion ( + ModuleVersion(..), mkModuleVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ModuleVersion + = -- | See: + ModuleVersion {haddock_workaround_ :: (), + -- | See: + moduleName :: (Value Prelude.Text), + -- | See: + modulePackage :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkModuleVersion :: + Value Prelude.Text -> Value Prelude.Text -> ModuleVersion +mkModuleVersion moduleName modulePackage + = ModuleVersion + {haddock_workaround_ = (), moduleName = moduleName, + modulePackage = modulePackage} +instance ToResourceProperties ModuleVersion where + toResourceProperties ModuleVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::ModuleVersion", + supportsTags = Prelude.False, + properties = ["ModuleName" JSON..= moduleName, + "ModulePackage" JSON..= modulePackage]} +instance JSON.ToJSON ModuleVersion where + toJSON ModuleVersion {..} + = JSON.object + ["ModuleName" JSON..= moduleName, + "ModulePackage" JSON..= modulePackage] +instance Property "ModuleName" ModuleVersion where + type PropertyType "ModuleName" ModuleVersion = Value Prelude.Text + set newValue ModuleVersion {..} + = ModuleVersion {moduleName = newValue, ..} +instance Property "ModulePackage" ModuleVersion where + type PropertyType "ModulePackage" ModuleVersion = Value Prelude.Text + set newValue ModuleVersion {..} + = ModuleVersion {modulePackage = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/PublicTypeVersion.hs b/gen/Stratosphere/CloudFormation/PublicTypeVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/PublicTypeVersion.hs @@ -0,0 +1,72 @@ +module Stratosphere.CloudFormation.PublicTypeVersion ( + PublicTypeVersion(..), mkPublicTypeVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data PublicTypeVersion + = -- | See: + PublicTypeVersion {haddock_workaround_ :: (), + -- | See: + arn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + logDeliveryBucket :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + publicVersionNumber :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + type' :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeName :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkPublicTypeVersion :: PublicTypeVersion +mkPublicTypeVersion + = PublicTypeVersion + {haddock_workaround_ = (), arn = Prelude.Nothing, + logDeliveryBucket = Prelude.Nothing, + publicVersionNumber = Prelude.Nothing, type' = Prelude.Nothing, + typeName = Prelude.Nothing} +instance ToResourceProperties PublicTypeVersion where + toResourceProperties PublicTypeVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::PublicTypeVersion", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Arn" Prelude.<$> arn, + (JSON..=) "LogDeliveryBucket" Prelude.<$> logDeliveryBucket, + (JSON..=) "PublicVersionNumber" Prelude.<$> publicVersionNumber, + (JSON..=) "Type" Prelude.<$> type', + (JSON..=) "TypeName" Prelude.<$> typeName])} +instance JSON.ToJSON PublicTypeVersion where + toJSON PublicTypeVersion {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Arn" Prelude.<$> arn, + (JSON..=) "LogDeliveryBucket" Prelude.<$> logDeliveryBucket, + (JSON..=) "PublicVersionNumber" Prelude.<$> publicVersionNumber, + (JSON..=) "Type" Prelude.<$> type', + (JSON..=) "TypeName" Prelude.<$> typeName])) +instance Property "Arn" PublicTypeVersion where + type PropertyType "Arn" PublicTypeVersion = Value Prelude.Text + set newValue PublicTypeVersion {..} + = PublicTypeVersion {arn = Prelude.pure newValue, ..} +instance Property "LogDeliveryBucket" PublicTypeVersion where + type PropertyType "LogDeliveryBucket" PublicTypeVersion = Value Prelude.Text + set newValue PublicTypeVersion {..} + = PublicTypeVersion {logDeliveryBucket = Prelude.pure newValue, ..} +instance Property "PublicVersionNumber" PublicTypeVersion where + type PropertyType "PublicVersionNumber" PublicTypeVersion = Value Prelude.Text + set newValue PublicTypeVersion {..} + = PublicTypeVersion + {publicVersionNumber = Prelude.pure newValue, ..} +instance Property "Type" PublicTypeVersion where + type PropertyType "Type" PublicTypeVersion = Value Prelude.Text + set newValue PublicTypeVersion {..} + = PublicTypeVersion {type' = Prelude.pure newValue, ..} +instance Property "TypeName" PublicTypeVersion where + type PropertyType "TypeName" PublicTypeVersion = Value Prelude.Text + set newValue PublicTypeVersion {..} + = PublicTypeVersion {typeName = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/Publisher.hs b/gen/Stratosphere/CloudFormation/Publisher.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/Publisher.hs @@ -0,0 +1,48 @@ +module Stratosphere.CloudFormation.Publisher ( + Publisher(..), mkPublisher + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data Publisher + = -- | See: + Publisher {haddock_workaround_ :: (), + -- | See: + acceptTermsAndConditions :: (Value Prelude.Bool), + -- | See: + connectionArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkPublisher :: Value Prelude.Bool -> Publisher +mkPublisher acceptTermsAndConditions + = Publisher + {haddock_workaround_ = (), + acceptTermsAndConditions = acceptTermsAndConditions, + connectionArn = Prelude.Nothing} +instance ToResourceProperties Publisher where + toResourceProperties Publisher {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::Publisher", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["AcceptTermsAndConditions" JSON..= acceptTermsAndConditions] + (Prelude.catMaybes + [(JSON..=) "ConnectionArn" Prelude.<$> connectionArn]))} +instance JSON.ToJSON Publisher where + toJSON Publisher {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["AcceptTermsAndConditions" JSON..= acceptTermsAndConditions] + (Prelude.catMaybes + [(JSON..=) "ConnectionArn" Prelude.<$> connectionArn]))) +instance Property "AcceptTermsAndConditions" Publisher where + type PropertyType "AcceptTermsAndConditions" Publisher = Value Prelude.Bool + set newValue Publisher {..} + = Publisher {acceptTermsAndConditions = newValue, ..} +instance Property "ConnectionArn" Publisher where + type PropertyType "ConnectionArn" Publisher = Value Prelude.Text + set newValue Publisher {..} + = Publisher {connectionArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/ResourceDefaultVersion.hs b/gen/Stratosphere/CloudFormation/ResourceDefaultVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/ResourceDefaultVersion.hs @@ -0,0 +1,54 @@ +module Stratosphere.CloudFormation.ResourceDefaultVersion ( + ResourceDefaultVersion(..), mkResourceDefaultVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ResourceDefaultVersion + = -- | See: + ResourceDefaultVersion {haddock_workaround_ :: (), + -- | See: + typeName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeVersionArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + versionId :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkResourceDefaultVersion :: ResourceDefaultVersion +mkResourceDefaultVersion + = ResourceDefaultVersion + {haddock_workaround_ = (), typeName = Prelude.Nothing, + typeVersionArn = Prelude.Nothing, versionId = Prelude.Nothing} +instance ToResourceProperties ResourceDefaultVersion where + toResourceProperties ResourceDefaultVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::ResourceDefaultVersion", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "TypeName" Prelude.<$> typeName, + (JSON..=) "TypeVersionArn" Prelude.<$> typeVersionArn, + (JSON..=) "VersionId" Prelude.<$> versionId])} +instance JSON.ToJSON ResourceDefaultVersion where + toJSON ResourceDefaultVersion {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "TypeName" Prelude.<$> typeName, + (JSON..=) "TypeVersionArn" Prelude.<$> typeVersionArn, + (JSON..=) "VersionId" Prelude.<$> versionId])) +instance Property "TypeName" ResourceDefaultVersion where + type PropertyType "TypeName" ResourceDefaultVersion = Value Prelude.Text + set newValue ResourceDefaultVersion {..} + = ResourceDefaultVersion {typeName = Prelude.pure newValue, ..} +instance Property "TypeVersionArn" ResourceDefaultVersion where + type PropertyType "TypeVersionArn" ResourceDefaultVersion = Value Prelude.Text + set newValue ResourceDefaultVersion {..} + = ResourceDefaultVersion + {typeVersionArn = Prelude.pure newValue, ..} +instance Property "VersionId" ResourceDefaultVersion where + type PropertyType "VersionId" ResourceDefaultVersion = Value Prelude.Text + set newValue ResourceDefaultVersion {..} + = ResourceDefaultVersion {versionId = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/ResourceVersion.hs b/gen/Stratosphere/CloudFormation/ResourceVersion.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/ResourceVersion.hs @@ -0,0 +1,67 @@ +module Stratosphere.CloudFormation.ResourceVersion ( + module Exports, ResourceVersion(..), mkResourceVersion + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.ResourceVersion.LoggingConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ResourceVersion + = -- | See: + ResourceVersion {haddock_workaround_ :: (), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + loggingConfig :: (Prelude.Maybe LoggingConfigProperty), + -- | See: + schemaHandlerPackage :: (Value Prelude.Text), + -- | See: + typeName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkResourceVersion :: + Value Prelude.Text -> Value Prelude.Text -> ResourceVersion +mkResourceVersion schemaHandlerPackage typeName + = ResourceVersion + {haddock_workaround_ = (), + schemaHandlerPackage = schemaHandlerPackage, typeName = typeName, + executionRoleArn = Prelude.Nothing, + loggingConfig = Prelude.Nothing} +instance ToResourceProperties ResourceVersion where + toResourceProperties ResourceVersion {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::ResourceVersion", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["SchemaHandlerPackage" JSON..= schemaHandlerPackage, + "TypeName" JSON..= typeName] + (Prelude.catMaybes + [(JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "LoggingConfig" Prelude.<$> loggingConfig]))} +instance JSON.ToJSON ResourceVersion where + toJSON ResourceVersion {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["SchemaHandlerPackage" JSON..= schemaHandlerPackage, + "TypeName" JSON..= typeName] + (Prelude.catMaybes + [(JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "LoggingConfig" Prelude.<$> loggingConfig]))) +instance Property "ExecutionRoleArn" ResourceVersion where + type PropertyType "ExecutionRoleArn" ResourceVersion = Value Prelude.Text + set newValue ResourceVersion {..} + = ResourceVersion {executionRoleArn = Prelude.pure newValue, ..} +instance Property "LoggingConfig" ResourceVersion where + type PropertyType "LoggingConfig" ResourceVersion = LoggingConfigProperty + set newValue ResourceVersion {..} + = ResourceVersion {loggingConfig = Prelude.pure newValue, ..} +instance Property "SchemaHandlerPackage" ResourceVersion where + type PropertyType "SchemaHandlerPackage" ResourceVersion = Value Prelude.Text + set newValue ResourceVersion {..} + = ResourceVersion {schemaHandlerPackage = newValue, ..} +instance Property "TypeName" ResourceVersion where + type PropertyType "TypeName" ResourceVersion = Value Prelude.Text + set newValue ResourceVersion {..} + = ResourceVersion {typeName = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/ResourceVersion/LoggingConfigProperty.hs b/gen/Stratosphere/CloudFormation/ResourceVersion/LoggingConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/ResourceVersion/LoggingConfigProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.ResourceVersion.LoggingConfigProperty ( + LoggingConfigProperty(..), mkLoggingConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LoggingConfigProperty + = -- | See: + LoggingConfigProperty {haddock_workaround_ :: (), + -- | See: + logGroupName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + logRoleArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingConfigProperty :: LoggingConfigProperty +mkLoggingConfigProperty + = LoggingConfigProperty + {haddock_workaround_ = (), logGroupName = Prelude.Nothing, + logRoleArn = Prelude.Nothing} +instance ToResourceProperties LoggingConfigProperty where + toResourceProperties LoggingConfigProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::ResourceVersion.LoggingConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleArn" Prelude.<$> logRoleArn])} +instance JSON.ToJSON LoggingConfigProperty where + toJSON LoggingConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleArn" Prelude.<$> logRoleArn])) +instance Property "LogGroupName" LoggingConfigProperty where + type PropertyType "LogGroupName" LoggingConfigProperty = Value Prelude.Text + set newValue LoggingConfigProperty {..} + = LoggingConfigProperty {logGroupName = Prelude.pure newValue, ..} +instance Property "LogRoleArn" LoggingConfigProperty where + type PropertyType "LogRoleArn" LoggingConfigProperty = Value Prelude.Text + set newValue LoggingConfigProperty {..} + = LoggingConfigProperty {logRoleArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/ResourceVersion/LoggingConfigProperty.hs-boot b/gen/Stratosphere/CloudFormation/ResourceVersion/LoggingConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/ResourceVersion/LoggingConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.ResourceVersion.LoggingConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingConfigProperty :: Prelude.Type +instance ToResourceProperties LoggingConfigProperty +instance Prelude.Eq LoggingConfigProperty +instance Prelude.Show LoggingConfigProperty +instance JSON.ToJSON LoggingConfigProperty diff --git a/gen/Stratosphere/CloudFormation/Stack.hs b/gen/Stratosphere/CloudFormation/Stack.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/Stack.hs @@ -0,0 +1,71 @@ +module Stratosphere.CloudFormation.Stack ( + Stack(..), mkStack + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data Stack + = -- | See: + Stack {haddock_workaround_ :: (), + -- | See: + notificationARNs :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + parameters :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + templateURL :: (Value Prelude.Text), + -- | See: + timeoutInMinutes :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkStack :: Value Prelude.Text -> Stack +mkStack templateURL + = Stack + {haddock_workaround_ = (), templateURL = templateURL, + notificationARNs = Prelude.Nothing, parameters = Prelude.Nothing, + tags = Prelude.Nothing, timeoutInMinutes = Prelude.Nothing} +instance ToResourceProperties Stack where + toResourceProperties Stack {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::Stack", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["TemplateURL" JSON..= templateURL] + (Prelude.catMaybes + [(JSON..=) "NotificationARNs" Prelude.<$> notificationARNs, + (JSON..=) "Parameters" Prelude.<$> parameters, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "TimeoutInMinutes" Prelude.<$> timeoutInMinutes]))} +instance JSON.ToJSON Stack where + toJSON Stack {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["TemplateURL" JSON..= templateURL] + (Prelude.catMaybes + [(JSON..=) "NotificationARNs" Prelude.<$> notificationARNs, + (JSON..=) "Parameters" Prelude.<$> parameters, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "TimeoutInMinutes" Prelude.<$> timeoutInMinutes]))) +instance Property "NotificationARNs" Stack where + type PropertyType "NotificationARNs" Stack = ValueList Prelude.Text + set newValue Stack {..} + = Stack {notificationARNs = Prelude.pure newValue, ..} +instance Property "Parameters" Stack where + type PropertyType "Parameters" Stack = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue Stack {..} + = Stack {parameters = Prelude.pure newValue, ..} +instance Property "Tags" Stack where + type PropertyType "Tags" Stack = [Tag] + set newValue Stack {..} = Stack {tags = Prelude.pure newValue, ..} +instance Property "TemplateURL" Stack where + type PropertyType "TemplateURL" Stack = Value Prelude.Text + set newValue Stack {..} = Stack {templateURL = newValue, ..} +instance Property "TimeoutInMinutes" Stack where + type PropertyType "TimeoutInMinutes" Stack = Value Prelude.Integer + set newValue Stack {..} + = Stack {timeoutInMinutes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet.hs b/gen/Stratosphere/CloudFormation/StackSet.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet.hs @@ -0,0 +1,167 @@ +module Stratosphere.CloudFormation.StackSet ( + module Exports, StackSet(..), mkStackSet + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.AutoDeploymentProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.ManagedExecutionProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.OperationPreferencesProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.ParameterProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.StackInstancesProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data StackSet + = -- | See: + StackSet {haddock_workaround_ :: (), + -- | See: + administrationRoleARN :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + autoDeployment :: (Prelude.Maybe AutoDeploymentProperty), + -- | See: + callAs :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + capabilities :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + description :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + executionRoleName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + managedExecution :: (Prelude.Maybe ManagedExecutionProperty), + -- | See: + operationPreferences :: (Prelude.Maybe OperationPreferencesProperty), + -- | See: + parameters :: (Prelude.Maybe [ParameterProperty]), + -- | See: + permissionModel :: (Value Prelude.Text), + -- | See: + stackInstancesGroup :: (Prelude.Maybe [StackInstancesProperty]), + -- | See: + stackSetName :: (Value Prelude.Text), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + templateBody :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + templateURL :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackSet :: Value Prelude.Text -> Value Prelude.Text -> StackSet +mkStackSet permissionModel stackSetName + = StackSet + {haddock_workaround_ = (), permissionModel = permissionModel, + stackSetName = stackSetName, + administrationRoleARN = Prelude.Nothing, + autoDeployment = Prelude.Nothing, callAs = Prelude.Nothing, + capabilities = Prelude.Nothing, description = Prelude.Nothing, + executionRoleName = Prelude.Nothing, + managedExecution = Prelude.Nothing, + operationPreferences = Prelude.Nothing, + parameters = Prelude.Nothing, + stackInstancesGroup = Prelude.Nothing, tags = Prelude.Nothing, + templateBody = Prelude.Nothing, templateURL = Prelude.Nothing} +instance ToResourceProperties StackSet where + toResourceProperties StackSet {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["PermissionModel" JSON..= permissionModel, + "StackSetName" JSON..= stackSetName] + (Prelude.catMaybes + [(JSON..=) "AdministrationRoleARN" + Prelude.<$> administrationRoleARN, + (JSON..=) "AutoDeployment" Prelude.<$> autoDeployment, + (JSON..=) "CallAs" Prelude.<$> callAs, + (JSON..=) "Capabilities" Prelude.<$> capabilities, + (JSON..=) "Description" Prelude.<$> description, + (JSON..=) "ExecutionRoleName" Prelude.<$> executionRoleName, + (JSON..=) "ManagedExecution" Prelude.<$> managedExecution, + (JSON..=) "OperationPreferences" Prelude.<$> operationPreferences, + (JSON..=) "Parameters" Prelude.<$> parameters, + (JSON..=) "StackInstancesGroup" Prelude.<$> stackInstancesGroup, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "TemplateBody" Prelude.<$> templateBody, + (JSON..=) "TemplateURL" Prelude.<$> templateURL]))} +instance JSON.ToJSON StackSet where + toJSON StackSet {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["PermissionModel" JSON..= permissionModel, + "StackSetName" JSON..= stackSetName] + (Prelude.catMaybes + [(JSON..=) "AdministrationRoleARN" + Prelude.<$> administrationRoleARN, + (JSON..=) "AutoDeployment" Prelude.<$> autoDeployment, + (JSON..=) "CallAs" Prelude.<$> callAs, + (JSON..=) "Capabilities" Prelude.<$> capabilities, + (JSON..=) "Description" Prelude.<$> description, + (JSON..=) "ExecutionRoleName" Prelude.<$> executionRoleName, + (JSON..=) "ManagedExecution" Prelude.<$> managedExecution, + (JSON..=) "OperationPreferences" Prelude.<$> operationPreferences, + (JSON..=) "Parameters" Prelude.<$> parameters, + (JSON..=) "StackInstancesGroup" Prelude.<$> stackInstancesGroup, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "TemplateBody" Prelude.<$> templateBody, + (JSON..=) "TemplateURL" Prelude.<$> templateURL]))) +instance Property "AdministrationRoleARN" StackSet where + type PropertyType "AdministrationRoleARN" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {administrationRoleARN = Prelude.pure newValue, ..} +instance Property "AutoDeployment" StackSet where + type PropertyType "AutoDeployment" StackSet = AutoDeploymentProperty + set newValue StackSet {..} + = StackSet {autoDeployment = Prelude.pure newValue, ..} +instance Property "CallAs" StackSet where + type PropertyType "CallAs" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {callAs = Prelude.pure newValue, ..} +instance Property "Capabilities" StackSet where + type PropertyType "Capabilities" StackSet = ValueList Prelude.Text + set newValue StackSet {..} + = StackSet {capabilities = Prelude.pure newValue, ..} +instance Property "Description" StackSet where + type PropertyType "Description" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {description = Prelude.pure newValue, ..} +instance Property "ExecutionRoleName" StackSet where + type PropertyType "ExecutionRoleName" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {executionRoleName = Prelude.pure newValue, ..} +instance Property "ManagedExecution" StackSet where + type PropertyType "ManagedExecution" StackSet = ManagedExecutionProperty + set newValue StackSet {..} + = StackSet {managedExecution = Prelude.pure newValue, ..} +instance Property "OperationPreferences" StackSet where + type PropertyType "OperationPreferences" StackSet = OperationPreferencesProperty + set newValue StackSet {..} + = StackSet {operationPreferences = Prelude.pure newValue, ..} +instance Property "Parameters" StackSet where + type PropertyType "Parameters" StackSet = [ParameterProperty] + set newValue StackSet {..} + = StackSet {parameters = Prelude.pure newValue, ..} +instance Property "PermissionModel" StackSet where + type PropertyType "PermissionModel" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {permissionModel = newValue, ..} +instance Property "StackInstancesGroup" StackSet where + type PropertyType "StackInstancesGroup" StackSet = [StackInstancesProperty] + set newValue StackSet {..} + = StackSet {stackInstancesGroup = Prelude.pure newValue, ..} +instance Property "StackSetName" StackSet where + type PropertyType "StackSetName" StackSet = Value Prelude.Text + set newValue StackSet {..} = StackSet {stackSetName = newValue, ..} +instance Property "Tags" StackSet where + type PropertyType "Tags" StackSet = [Tag] + set newValue StackSet {..} + = StackSet {tags = Prelude.pure newValue, ..} +instance Property "TemplateBody" StackSet where + type PropertyType "TemplateBody" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {templateBody = Prelude.pure newValue, ..} +instance Property "TemplateURL" StackSet where + type PropertyType "TemplateURL" StackSet = Value Prelude.Text + set newValue StackSet {..} + = StackSet {templateURL = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/AutoDeploymentProperty.hs b/gen/Stratosphere/CloudFormation/StackSet/AutoDeploymentProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/AutoDeploymentProperty.hs @@ -0,0 +1,48 @@ +module Stratosphere.CloudFormation.StackSet.AutoDeploymentProperty ( + AutoDeploymentProperty(..), mkAutoDeploymentProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AutoDeploymentProperty + = -- | See: + AutoDeploymentProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + retainStacksOnAccountRemoval :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkAutoDeploymentProperty :: AutoDeploymentProperty +mkAutoDeploymentProperty + = AutoDeploymentProperty + {haddock_workaround_ = (), enabled = Prelude.Nothing, + retainStacksOnAccountRemoval = Prelude.Nothing} +instance ToResourceProperties AutoDeploymentProperty where + toResourceProperties AutoDeploymentProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet.AutoDeployment", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Enabled" Prelude.<$> enabled, + (JSON..=) "RetainStacksOnAccountRemoval" + Prelude.<$> retainStacksOnAccountRemoval])} +instance JSON.ToJSON AutoDeploymentProperty where + toJSON AutoDeploymentProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Enabled" Prelude.<$> enabled, + (JSON..=) "RetainStacksOnAccountRemoval" + Prelude.<$> retainStacksOnAccountRemoval])) +instance Property "Enabled" AutoDeploymentProperty where + type PropertyType "Enabled" AutoDeploymentProperty = Value Prelude.Bool + set newValue AutoDeploymentProperty {..} + = AutoDeploymentProperty {enabled = Prelude.pure newValue, ..} +instance Property "RetainStacksOnAccountRemoval" AutoDeploymentProperty where + type PropertyType "RetainStacksOnAccountRemoval" AutoDeploymentProperty = Value Prelude.Bool + set newValue AutoDeploymentProperty {..} + = AutoDeploymentProperty + {retainStacksOnAccountRemoval = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/AutoDeploymentProperty.hs-boot b/gen/Stratosphere/CloudFormation/StackSet/AutoDeploymentProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/AutoDeploymentProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.StackSet.AutoDeploymentProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AutoDeploymentProperty :: Prelude.Type +instance ToResourceProperties AutoDeploymentProperty +instance Prelude.Eq AutoDeploymentProperty +instance Prelude.Show AutoDeploymentProperty +instance JSON.ToJSON AutoDeploymentProperty diff --git a/gen/Stratosphere/CloudFormation/StackSet/DeploymentTargetsProperty.hs b/gen/Stratosphere/CloudFormation/StackSet/DeploymentTargetsProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/DeploymentTargetsProperty.hs @@ -0,0 +1,67 @@ +module Stratosphere.CloudFormation.StackSet.DeploymentTargetsProperty ( + DeploymentTargetsProperty(..), mkDeploymentTargetsProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data DeploymentTargetsProperty + = -- | See: + DeploymentTargetsProperty {haddock_workaround_ :: (), + -- | See: + accountFilterType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + accounts :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + accountsUrl :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + organizationalUnitIds :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkDeploymentTargetsProperty :: DeploymentTargetsProperty +mkDeploymentTargetsProperty + = DeploymentTargetsProperty + {haddock_workaround_ = (), accountFilterType = Prelude.Nothing, + accounts = Prelude.Nothing, accountsUrl = Prelude.Nothing, + organizationalUnitIds = Prelude.Nothing} +instance ToResourceProperties DeploymentTargetsProperty where + toResourceProperties DeploymentTargetsProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet.DeploymentTargets", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AccountFilterType" Prelude.<$> accountFilterType, + (JSON..=) "Accounts" Prelude.<$> accounts, + (JSON..=) "AccountsUrl" Prelude.<$> accountsUrl, + (JSON..=) "OrganizationalUnitIds" + Prelude.<$> organizationalUnitIds])} +instance JSON.ToJSON DeploymentTargetsProperty where + toJSON DeploymentTargetsProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AccountFilterType" Prelude.<$> accountFilterType, + (JSON..=) "Accounts" Prelude.<$> accounts, + (JSON..=) "AccountsUrl" Prelude.<$> accountsUrl, + (JSON..=) "OrganizationalUnitIds" + Prelude.<$> organizationalUnitIds])) +instance Property "AccountFilterType" DeploymentTargetsProperty where + type PropertyType "AccountFilterType" DeploymentTargetsProperty = Value Prelude.Text + set newValue DeploymentTargetsProperty {..} + = DeploymentTargetsProperty + {accountFilterType = Prelude.pure newValue, ..} +instance Property "Accounts" DeploymentTargetsProperty where + type PropertyType "Accounts" DeploymentTargetsProperty = ValueList Prelude.Text + set newValue DeploymentTargetsProperty {..} + = DeploymentTargetsProperty {accounts = Prelude.pure newValue, ..} +instance Property "AccountsUrl" DeploymentTargetsProperty where + type PropertyType "AccountsUrl" DeploymentTargetsProperty = Value Prelude.Text + set newValue DeploymentTargetsProperty {..} + = DeploymentTargetsProperty + {accountsUrl = Prelude.pure newValue, ..} +instance Property "OrganizationalUnitIds" DeploymentTargetsProperty where + type PropertyType "OrganizationalUnitIds" DeploymentTargetsProperty = ValueList Prelude.Text + set newValue DeploymentTargetsProperty {..} + = DeploymentTargetsProperty + {organizationalUnitIds = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/DeploymentTargetsProperty.hs-boot b/gen/Stratosphere/CloudFormation/StackSet/DeploymentTargetsProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/DeploymentTargetsProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.StackSet.DeploymentTargetsProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data DeploymentTargetsProperty :: Prelude.Type +instance ToResourceProperties DeploymentTargetsProperty +instance Prelude.Eq DeploymentTargetsProperty +instance Prelude.Show DeploymentTargetsProperty +instance JSON.ToJSON DeploymentTargetsProperty diff --git a/gen/Stratosphere/CloudFormation/StackSet/ManagedExecutionProperty.hs b/gen/Stratosphere/CloudFormation/StackSet/ManagedExecutionProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/ManagedExecutionProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.CloudFormation.StackSet.ManagedExecutionProperty ( + ManagedExecutionProperty(..), mkManagedExecutionProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ManagedExecutionProperty + = -- | See: + ManagedExecutionProperty {haddock_workaround_ :: (), + -- | See: + active :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkManagedExecutionProperty :: ManagedExecutionProperty +mkManagedExecutionProperty + = ManagedExecutionProperty + {haddock_workaround_ = (), active = Prelude.Nothing} +instance ToResourceProperties ManagedExecutionProperty where + toResourceProperties ManagedExecutionProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet.ManagedExecution", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Active" Prelude.<$> active])} +instance JSON.ToJSON ManagedExecutionProperty where + toJSON ManagedExecutionProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Active" Prelude.<$> active])) +instance Property "Active" ManagedExecutionProperty where + type PropertyType "Active" ManagedExecutionProperty = Value Prelude.Bool + set newValue ManagedExecutionProperty {..} + = ManagedExecutionProperty {active = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/ManagedExecutionProperty.hs-boot b/gen/Stratosphere/CloudFormation/StackSet/ManagedExecutionProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/ManagedExecutionProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.StackSet.ManagedExecutionProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ManagedExecutionProperty :: Prelude.Type +instance ToResourceProperties ManagedExecutionProperty +instance Prelude.Eq ManagedExecutionProperty +instance Prelude.Show ManagedExecutionProperty +instance JSON.ToJSON ManagedExecutionProperty diff --git a/gen/Stratosphere/CloudFormation/StackSet/OperationPreferencesProperty.hs b/gen/Stratosphere/CloudFormation/StackSet/OperationPreferencesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/OperationPreferencesProperty.hs @@ -0,0 +1,105 @@ +module Stratosphere.CloudFormation.StackSet.OperationPreferencesProperty ( + OperationPreferencesProperty(..), mkOperationPreferencesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data OperationPreferencesProperty + = -- | See: + OperationPreferencesProperty {haddock_workaround_ :: (), + -- | See: + concurrencyMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + failureToleranceCount :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + failureTolerancePercentage :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + maxConcurrentCount :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + maxConcurrentPercentage :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + regionConcurrencyType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + regionOrder :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkOperationPreferencesProperty :: OperationPreferencesProperty +mkOperationPreferencesProperty + = OperationPreferencesProperty + {haddock_workaround_ = (), concurrencyMode = Prelude.Nothing, + failureToleranceCount = Prelude.Nothing, + failureTolerancePercentage = Prelude.Nothing, + maxConcurrentCount = Prelude.Nothing, + maxConcurrentPercentage = Prelude.Nothing, + regionConcurrencyType = Prelude.Nothing, + regionOrder = Prelude.Nothing} +instance ToResourceProperties OperationPreferencesProperty where + toResourceProperties OperationPreferencesProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet.OperationPreferences", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ConcurrencyMode" Prelude.<$> concurrencyMode, + (JSON..=) "FailureToleranceCount" + Prelude.<$> failureToleranceCount, + (JSON..=) "FailureTolerancePercentage" + Prelude.<$> failureTolerancePercentage, + (JSON..=) "MaxConcurrentCount" Prelude.<$> maxConcurrentCount, + (JSON..=) "MaxConcurrentPercentage" + Prelude.<$> maxConcurrentPercentage, + (JSON..=) "RegionConcurrencyType" + Prelude.<$> regionConcurrencyType, + (JSON..=) "RegionOrder" Prelude.<$> regionOrder])} +instance JSON.ToJSON OperationPreferencesProperty where + toJSON OperationPreferencesProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ConcurrencyMode" Prelude.<$> concurrencyMode, + (JSON..=) "FailureToleranceCount" + Prelude.<$> failureToleranceCount, + (JSON..=) "FailureTolerancePercentage" + Prelude.<$> failureTolerancePercentage, + (JSON..=) "MaxConcurrentCount" Prelude.<$> maxConcurrentCount, + (JSON..=) "MaxConcurrentPercentage" + Prelude.<$> maxConcurrentPercentage, + (JSON..=) "RegionConcurrencyType" + Prelude.<$> regionConcurrencyType, + (JSON..=) "RegionOrder" Prelude.<$> regionOrder])) +instance Property "ConcurrencyMode" OperationPreferencesProperty where + type PropertyType "ConcurrencyMode" OperationPreferencesProperty = Value Prelude.Text + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {concurrencyMode = Prelude.pure newValue, ..} +instance Property "FailureToleranceCount" OperationPreferencesProperty where + type PropertyType "FailureToleranceCount" OperationPreferencesProperty = Value Prelude.Integer + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {failureToleranceCount = Prelude.pure newValue, ..} +instance Property "FailureTolerancePercentage" OperationPreferencesProperty where + type PropertyType "FailureTolerancePercentage" OperationPreferencesProperty = Value Prelude.Integer + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {failureTolerancePercentage = Prelude.pure newValue, ..} +instance Property "MaxConcurrentCount" OperationPreferencesProperty where + type PropertyType "MaxConcurrentCount" OperationPreferencesProperty = Value Prelude.Integer + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {maxConcurrentCount = Prelude.pure newValue, ..} +instance Property "MaxConcurrentPercentage" OperationPreferencesProperty where + type PropertyType "MaxConcurrentPercentage" OperationPreferencesProperty = Value Prelude.Integer + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {maxConcurrentPercentage = Prelude.pure newValue, ..} +instance Property "RegionConcurrencyType" OperationPreferencesProperty where + type PropertyType "RegionConcurrencyType" OperationPreferencesProperty = Value Prelude.Text + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {regionConcurrencyType = Prelude.pure newValue, ..} +instance Property "RegionOrder" OperationPreferencesProperty where + type PropertyType "RegionOrder" OperationPreferencesProperty = ValueList Prelude.Text + set newValue OperationPreferencesProperty {..} + = OperationPreferencesProperty + {regionOrder = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/OperationPreferencesProperty.hs-boot b/gen/Stratosphere/CloudFormation/StackSet/OperationPreferencesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/OperationPreferencesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.StackSet.OperationPreferencesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data OperationPreferencesProperty :: Prelude.Type +instance ToResourceProperties OperationPreferencesProperty +instance Prelude.Eq OperationPreferencesProperty +instance Prelude.Show OperationPreferencesProperty +instance JSON.ToJSON OperationPreferencesProperty diff --git a/gen/Stratosphere/CloudFormation/StackSet/ParameterProperty.hs b/gen/Stratosphere/CloudFormation/StackSet/ParameterProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/ParameterProperty.hs @@ -0,0 +1,42 @@ +module Stratosphere.CloudFormation.StackSet.ParameterProperty ( + ParameterProperty(..), mkParameterProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ParameterProperty + = -- | See: + ParameterProperty {haddock_workaround_ :: (), + -- | See: + parameterKey :: (Value Prelude.Text), + -- | See: + parameterValue :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkParameterProperty :: + Value Prelude.Text -> Value Prelude.Text -> ParameterProperty +mkParameterProperty parameterKey parameterValue + = ParameterProperty + {haddock_workaround_ = (), parameterKey = parameterKey, + parameterValue = parameterValue} +instance ToResourceProperties ParameterProperty where + toResourceProperties ParameterProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet.Parameter", + supportsTags = Prelude.False, + properties = ["ParameterKey" JSON..= parameterKey, + "ParameterValue" JSON..= parameterValue]} +instance JSON.ToJSON ParameterProperty where + toJSON ParameterProperty {..} + = JSON.object + ["ParameterKey" JSON..= parameterKey, + "ParameterValue" JSON..= parameterValue] +instance Property "ParameterKey" ParameterProperty where + type PropertyType "ParameterKey" ParameterProperty = Value Prelude.Text + set newValue ParameterProperty {..} + = ParameterProperty {parameterKey = newValue, ..} +instance Property "ParameterValue" ParameterProperty where + type PropertyType "ParameterValue" ParameterProperty = Value Prelude.Text + set newValue ParameterProperty {..} + = ParameterProperty {parameterValue = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/ParameterProperty.hs-boot b/gen/Stratosphere/CloudFormation/StackSet/ParameterProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/ParameterProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.StackSet.ParameterProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ParameterProperty :: Prelude.Type +instance ToResourceProperties ParameterProperty +instance Prelude.Eq ParameterProperty +instance Prelude.Show ParameterProperty +instance JSON.ToJSON ParameterProperty diff --git a/gen/Stratosphere/CloudFormation/StackSet/StackInstancesProperty.hs b/gen/Stratosphere/CloudFormation/StackSet/StackInstancesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/StackInstancesProperty.hs @@ -0,0 +1,61 @@ +module Stratosphere.CloudFormation.StackSet.StackInstancesProperty ( + module Exports, StackInstancesProperty(..), + mkStackInstancesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.DeploymentTargetsProperty as Exports +import {-# SOURCE #-} Stratosphere.CloudFormation.StackSet.ParameterProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data StackInstancesProperty + = -- | See: + StackInstancesProperty {haddock_workaround_ :: (), + -- | See: + deploymentTargets :: DeploymentTargetsProperty, + -- | See: + parameterOverrides :: (Prelude.Maybe [ParameterProperty]), + -- | See: + regions :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkStackInstancesProperty :: + DeploymentTargetsProperty + -> ValueList Prelude.Text -> StackInstancesProperty +mkStackInstancesProperty deploymentTargets regions + = StackInstancesProperty + {haddock_workaround_ = (), deploymentTargets = deploymentTargets, + regions = regions, parameterOverrides = Prelude.Nothing} +instance ToResourceProperties StackInstancesProperty where + toResourceProperties StackInstancesProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::StackSet.StackInstances", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["DeploymentTargets" JSON..= deploymentTargets, + "Regions" JSON..= regions] + (Prelude.catMaybes + [(JSON..=) "ParameterOverrides" Prelude.<$> parameterOverrides]))} +instance JSON.ToJSON StackInstancesProperty where + toJSON StackInstancesProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["DeploymentTargets" JSON..= deploymentTargets, + "Regions" JSON..= regions] + (Prelude.catMaybes + [(JSON..=) "ParameterOverrides" Prelude.<$> parameterOverrides]))) +instance Property "DeploymentTargets" StackInstancesProperty where + type PropertyType "DeploymentTargets" StackInstancesProperty = DeploymentTargetsProperty + set newValue StackInstancesProperty {..} + = StackInstancesProperty {deploymentTargets = newValue, ..} +instance Property "ParameterOverrides" StackInstancesProperty where + type PropertyType "ParameterOverrides" StackInstancesProperty = [ParameterProperty] + set newValue StackInstancesProperty {..} + = StackInstancesProperty + {parameterOverrides = Prelude.pure newValue, ..} +instance Property "Regions" StackInstancesProperty where + type PropertyType "Regions" StackInstancesProperty = ValueList Prelude.Text + set newValue StackInstancesProperty {..} + = StackInstancesProperty {regions = newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/StackSet/StackInstancesProperty.hs-boot b/gen/Stratosphere/CloudFormation/StackSet/StackInstancesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/StackSet/StackInstancesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.StackSet.StackInstancesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StackInstancesProperty :: Prelude.Type +instance ToResourceProperties StackInstancesProperty +instance Prelude.Eq StackInstancesProperty +instance Prelude.Show StackInstancesProperty +instance JSON.ToJSON StackInstancesProperty diff --git a/gen/Stratosphere/CloudFormation/TypeActivation.hs b/gen/Stratosphere/CloudFormation/TypeActivation.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/TypeActivation.hs @@ -0,0 +1,114 @@ +module Stratosphere.CloudFormation.TypeActivation ( + module Exports, TypeActivation(..), mkTypeActivation + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.CloudFormation.TypeActivation.LoggingConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TypeActivation + = -- | See: + TypeActivation {haddock_workaround_ :: (), + -- | See: + autoUpdate :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + executionRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + loggingConfig :: (Prelude.Maybe LoggingConfigProperty), + -- | See: + majorVersion :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + publicTypeArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + publisherId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + type' :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + typeNameAlias :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + versionBump :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkTypeActivation :: TypeActivation +mkTypeActivation + = TypeActivation + {haddock_workaround_ = (), autoUpdate = Prelude.Nothing, + executionRoleArn = Prelude.Nothing, + loggingConfig = Prelude.Nothing, majorVersion = Prelude.Nothing, + publicTypeArn = Prelude.Nothing, publisherId = Prelude.Nothing, + type' = Prelude.Nothing, typeName = Prelude.Nothing, + typeNameAlias = Prelude.Nothing, versionBump = Prelude.Nothing} +instance ToResourceProperties TypeActivation where + toResourceProperties TypeActivation {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::TypeActivation", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AutoUpdate" Prelude.<$> autoUpdate, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "LoggingConfig" Prelude.<$> loggingConfig, + (JSON..=) "MajorVersion" Prelude.<$> majorVersion, + (JSON..=) "PublicTypeArn" Prelude.<$> publicTypeArn, + (JSON..=) "PublisherId" Prelude.<$> publisherId, + (JSON..=) "Type" Prelude.<$> type', + (JSON..=) "TypeName" Prelude.<$> typeName, + (JSON..=) "TypeNameAlias" Prelude.<$> typeNameAlias, + (JSON..=) "VersionBump" Prelude.<$> versionBump])} +instance JSON.ToJSON TypeActivation where + toJSON TypeActivation {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AutoUpdate" Prelude.<$> autoUpdate, + (JSON..=) "ExecutionRoleArn" Prelude.<$> executionRoleArn, + (JSON..=) "LoggingConfig" Prelude.<$> loggingConfig, + (JSON..=) "MajorVersion" Prelude.<$> majorVersion, + (JSON..=) "PublicTypeArn" Prelude.<$> publicTypeArn, + (JSON..=) "PublisherId" Prelude.<$> publisherId, + (JSON..=) "Type" Prelude.<$> type', + (JSON..=) "TypeName" Prelude.<$> typeName, + (JSON..=) "TypeNameAlias" Prelude.<$> typeNameAlias, + (JSON..=) "VersionBump" Prelude.<$> versionBump])) +instance Property "AutoUpdate" TypeActivation where + type PropertyType "AutoUpdate" TypeActivation = Value Prelude.Bool + set newValue TypeActivation {..} + = TypeActivation {autoUpdate = Prelude.pure newValue, ..} +instance Property "ExecutionRoleArn" TypeActivation where + type PropertyType "ExecutionRoleArn" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {executionRoleArn = Prelude.pure newValue, ..} +instance Property "LoggingConfig" TypeActivation where + type PropertyType "LoggingConfig" TypeActivation = LoggingConfigProperty + set newValue TypeActivation {..} + = TypeActivation {loggingConfig = Prelude.pure newValue, ..} +instance Property "MajorVersion" TypeActivation where + type PropertyType "MajorVersion" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {majorVersion = Prelude.pure newValue, ..} +instance Property "PublicTypeArn" TypeActivation where + type PropertyType "PublicTypeArn" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {publicTypeArn = Prelude.pure newValue, ..} +instance Property "PublisherId" TypeActivation where + type PropertyType "PublisherId" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {publisherId = Prelude.pure newValue, ..} +instance Property "Type" TypeActivation where + type PropertyType "Type" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {type' = Prelude.pure newValue, ..} +instance Property "TypeName" TypeActivation where + type PropertyType "TypeName" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {typeName = Prelude.pure newValue, ..} +instance Property "TypeNameAlias" TypeActivation where + type PropertyType "TypeNameAlias" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {typeNameAlias = Prelude.pure newValue, ..} +instance Property "VersionBump" TypeActivation where + type PropertyType "VersionBump" TypeActivation = Value Prelude.Text + set newValue TypeActivation {..} + = TypeActivation {versionBump = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/TypeActivation/LoggingConfigProperty.hs b/gen/Stratosphere/CloudFormation/TypeActivation/LoggingConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/TypeActivation/LoggingConfigProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.CloudFormation.TypeActivation.LoggingConfigProperty ( + LoggingConfigProperty(..), mkLoggingConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LoggingConfigProperty + = -- | See: + LoggingConfigProperty {haddock_workaround_ :: (), + -- | See: + logGroupName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + logRoleArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingConfigProperty :: LoggingConfigProperty +mkLoggingConfigProperty + = LoggingConfigProperty + {haddock_workaround_ = (), logGroupName = Prelude.Nothing, + logRoleArn = Prelude.Nothing} +instance ToResourceProperties LoggingConfigProperty where + toResourceProperties LoggingConfigProperty {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::TypeActivation.LoggingConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleArn" Prelude.<$> logRoleArn])} +instance JSON.ToJSON LoggingConfigProperty where + toJSON LoggingConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupName" Prelude.<$> logGroupName, + (JSON..=) "LogRoleArn" Prelude.<$> logRoleArn])) +instance Property "LogGroupName" LoggingConfigProperty where + type PropertyType "LogGroupName" LoggingConfigProperty = Value Prelude.Text + set newValue LoggingConfigProperty {..} + = LoggingConfigProperty {logGroupName = Prelude.pure newValue, ..} +instance Property "LogRoleArn" LoggingConfigProperty where + type PropertyType "LogRoleArn" LoggingConfigProperty = Value Prelude.Text + set newValue LoggingConfigProperty {..} + = LoggingConfigProperty {logRoleArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/TypeActivation/LoggingConfigProperty.hs-boot b/gen/Stratosphere/CloudFormation/TypeActivation/LoggingConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/TypeActivation/LoggingConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.CloudFormation.TypeActivation.LoggingConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingConfigProperty :: Prelude.Type +instance ToResourceProperties LoggingConfigProperty +instance Prelude.Eq LoggingConfigProperty +instance Prelude.Show LoggingConfigProperty +instance JSON.ToJSON LoggingConfigProperty diff --git a/gen/Stratosphere/CloudFormation/WaitCondition.hs b/gen/Stratosphere/CloudFormation/WaitCondition.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/WaitCondition.hs @@ -0,0 +1,53 @@ +module Stratosphere.CloudFormation.WaitCondition ( + WaitCondition(..), mkWaitCondition + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data WaitCondition + = -- | See: + WaitCondition {haddock_workaround_ :: (), + -- | See: + count :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + handle :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + timeout :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkWaitCondition :: WaitCondition +mkWaitCondition + = WaitCondition + {haddock_workaround_ = (), count = Prelude.Nothing, + handle = Prelude.Nothing, timeout = Prelude.Nothing} +instance ToResourceProperties WaitCondition where + toResourceProperties WaitCondition {..} + = ResourceProperties + {awsType = "AWS::CloudFormation::WaitCondition", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Count" Prelude.<$> count, + (JSON..=) "Handle" Prelude.<$> handle, + (JSON..=) "Timeout" Prelude.<$> timeout])} +instance JSON.ToJSON WaitCondition where + toJSON WaitCondition {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Count" Prelude.<$> count, + (JSON..=) "Handle" Prelude.<$> handle, + (JSON..=) "Timeout" Prelude.<$> timeout])) +instance Property "Count" WaitCondition where + type PropertyType "Count" WaitCondition = Value Prelude.Integer + set newValue WaitCondition {..} + = WaitCondition {count = Prelude.pure newValue, ..} +instance Property "Handle" WaitCondition where + type PropertyType "Handle" WaitCondition = Value Prelude.Text + set newValue WaitCondition {..} + = WaitCondition {handle = Prelude.pure newValue, ..} +instance Property "Timeout" WaitCondition where + type PropertyType "Timeout" WaitCondition = Value Prelude.Text + set newValue WaitCondition {..} + = WaitCondition {timeout = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/CloudFormation/WaitConditionHandle.hs b/gen/Stratosphere/CloudFormation/WaitConditionHandle.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/CloudFormation/WaitConditionHandle.hs @@ -0,0 +1,20 @@ +module Stratosphere.CloudFormation.WaitConditionHandle ( + WaitConditionHandle(..), mkWaitConditionHandle + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data WaitConditionHandle + = -- | See: + WaitConditionHandle {haddock_workaround_ :: ()} + deriving stock (Prelude.Eq, Prelude.Show) +mkWaitConditionHandle :: WaitConditionHandle +mkWaitConditionHandle + = WaitConditionHandle {haddock_workaround_ = ()} +instance ToResourceProperties WaitConditionHandle where + toResourceProperties WaitConditionHandle {} + = ResourceProperties + {awsType = "AWS::CloudFormation::WaitConditionHandle", + supportsTags = Prelude.False, properties = []} +instance JSON.ToJSON WaitConditionHandle where + toJSON WaitConditionHandle {} = JSON.object [] diff --git a/stratosphere-cloudformation.cabal b/stratosphere-cloudformation.cabal new file mode 100644 --- /dev/null +++ b/stratosphere-cloudformation.cabal @@ -0,0 +1,111 @@ +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-cloudformation +version: 1.0.0 +synopsis: Stratosphere integration for AWS CloudFormation. +description: Integration into stratosphere to generate resources and properties for AWS CloudFormation +category: AWS, Cloud, CloudFormation +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.CloudFormation.CustomResource + Stratosphere.CloudFormation.GuardHook + Stratosphere.CloudFormation.GuardHook.HookTargetProperty + Stratosphere.CloudFormation.GuardHook.OptionsProperty + Stratosphere.CloudFormation.GuardHook.S3LocationProperty + Stratosphere.CloudFormation.GuardHook.StackFiltersProperty + Stratosphere.CloudFormation.GuardHook.StackNamesProperty + Stratosphere.CloudFormation.GuardHook.StackRolesProperty + Stratosphere.CloudFormation.GuardHook.TargetFiltersProperty + Stratosphere.CloudFormation.HookDefaultVersion + Stratosphere.CloudFormation.HookTypeConfig + Stratosphere.CloudFormation.HookVersion + Stratosphere.CloudFormation.HookVersion.LoggingConfigProperty + Stratosphere.CloudFormation.LambdaHook + Stratosphere.CloudFormation.LambdaHook.HookTargetProperty + Stratosphere.CloudFormation.LambdaHook.StackFiltersProperty + Stratosphere.CloudFormation.LambdaHook.StackNamesProperty + Stratosphere.CloudFormation.LambdaHook.StackRolesProperty + Stratosphere.CloudFormation.LambdaHook.TargetFiltersProperty + Stratosphere.CloudFormation.Macro + Stratosphere.CloudFormation.ModuleDefaultVersion + Stratosphere.CloudFormation.ModuleVersion + Stratosphere.CloudFormation.PublicTypeVersion + Stratosphere.CloudFormation.Publisher + Stratosphere.CloudFormation.ResourceDefaultVersion + Stratosphere.CloudFormation.ResourceVersion + Stratosphere.CloudFormation.ResourceVersion.LoggingConfigProperty + Stratosphere.CloudFormation.Stack + Stratosphere.CloudFormation.StackSet + Stratosphere.CloudFormation.StackSet.AutoDeploymentProperty + Stratosphere.CloudFormation.StackSet.DeploymentTargetsProperty + Stratosphere.CloudFormation.StackSet.ManagedExecutionProperty + Stratosphere.CloudFormation.StackSet.OperationPreferencesProperty + Stratosphere.CloudFormation.StackSet.ParameterProperty + Stratosphere.CloudFormation.StackSet.StackInstancesProperty + Stratosphere.CloudFormation.TypeActivation + Stratosphere.CloudFormation.TypeActivation.LoggingConfigProperty + Stratosphere.CloudFormation.WaitCondition + Stratosphere.CloudFormation.WaitConditionHandle + other-modules: + Paths_stratosphere_cloudformation + 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