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/APS/AnomalyDetector.hs b/gen/Stratosphere/APS/AnomalyDetector.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector.hs @@ -0,0 +1,98 @@ +module Stratosphere.APS.AnomalyDetector ( + module Exports, AnomalyDetector(..), mkAnomalyDetector + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.AnomalyDetector.AnomalyDetectorConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.AnomalyDetector.LabelProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.AnomalyDetector.MissingDataActionProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data AnomalyDetector + = -- | See: + AnomalyDetector {haddock_workaround_ :: (), + -- | See: + alias :: (Value Prelude.Text), + -- | See: + configuration :: AnomalyDetectorConfigurationProperty, + -- | See: + evaluationIntervalInSeconds :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + labels :: (Prelude.Maybe [LabelProperty]), + -- | See: + missingDataAction :: (Prelude.Maybe MissingDataActionProperty), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + workspace :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkAnomalyDetector :: + Value Prelude.Text + -> AnomalyDetectorConfigurationProperty + -> Value Prelude.Text -> AnomalyDetector +mkAnomalyDetector alias configuration workspace + = AnomalyDetector + {haddock_workaround_ = (), alias = alias, + configuration = configuration, workspace = workspace, + evaluationIntervalInSeconds = Prelude.Nothing, + labels = Prelude.Nothing, missingDataAction = Prelude.Nothing, + tags = Prelude.Nothing} +instance ToResourceProperties AnomalyDetector where + toResourceProperties AnomalyDetector {..} + = ResourceProperties + {awsType = "AWS::APS::AnomalyDetector", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Alias" JSON..= alias, "Configuration" JSON..= configuration, + "Workspace" JSON..= workspace] + (Prelude.catMaybes + [(JSON..=) "EvaluationIntervalInSeconds" + Prelude.<$> evaluationIntervalInSeconds, + (JSON..=) "Labels" Prelude.<$> labels, + (JSON..=) "MissingDataAction" Prelude.<$> missingDataAction, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON AnomalyDetector where + toJSON AnomalyDetector {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Alias" JSON..= alias, "Configuration" JSON..= configuration, + "Workspace" JSON..= workspace] + (Prelude.catMaybes + [(JSON..=) "EvaluationIntervalInSeconds" + Prelude.<$> evaluationIntervalInSeconds, + (JSON..=) "Labels" Prelude.<$> labels, + (JSON..=) "MissingDataAction" Prelude.<$> missingDataAction, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "Alias" AnomalyDetector where + type PropertyType "Alias" AnomalyDetector = Value Prelude.Text + set newValue AnomalyDetector {..} + = AnomalyDetector {alias = newValue, ..} +instance Property "Configuration" AnomalyDetector where + type PropertyType "Configuration" AnomalyDetector = AnomalyDetectorConfigurationProperty + set newValue AnomalyDetector {..} + = AnomalyDetector {configuration = newValue, ..} +instance Property "EvaluationIntervalInSeconds" AnomalyDetector where + type PropertyType "EvaluationIntervalInSeconds" AnomalyDetector = Value Prelude.Integer + set newValue AnomalyDetector {..} + = AnomalyDetector + {evaluationIntervalInSeconds = Prelude.pure newValue, ..} +instance Property "Labels" AnomalyDetector where + type PropertyType "Labels" AnomalyDetector = [LabelProperty] + set newValue AnomalyDetector {..} + = AnomalyDetector {labels = Prelude.pure newValue, ..} +instance Property "MissingDataAction" AnomalyDetector where + type PropertyType "MissingDataAction" AnomalyDetector = MissingDataActionProperty + set newValue AnomalyDetector {..} + = AnomalyDetector {missingDataAction = Prelude.pure newValue, ..} +instance Property "Tags" AnomalyDetector where + type PropertyType "Tags" AnomalyDetector = [Tag] + set newValue AnomalyDetector {..} + = AnomalyDetector {tags = Prelude.pure newValue, ..} +instance Property "Workspace" AnomalyDetector where + type PropertyType "Workspace" AnomalyDetector = Value Prelude.Text + set newValue AnomalyDetector {..} + = AnomalyDetector {workspace = newValue, ..} diff --git a/gen/Stratosphere/APS/AnomalyDetector/AnomalyDetectorConfigurationProperty.hs b/gen/Stratosphere/APS/AnomalyDetector/AnomalyDetectorConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/AnomalyDetectorConfigurationProperty.hs @@ -0,0 +1,35 @@ +module Stratosphere.APS.AnomalyDetector.AnomalyDetectorConfigurationProperty ( + module Exports, AnomalyDetectorConfigurationProperty(..), + mkAnomalyDetectorConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.AnomalyDetector.RandomCutForestConfigurationProperty as Exports +import Stratosphere.ResourceProperties +data AnomalyDetectorConfigurationProperty + = -- | See: + AnomalyDetectorConfigurationProperty {haddock_workaround_ :: (), + -- | See: + randomCutForest :: RandomCutForestConfigurationProperty} + deriving stock (Prelude.Eq, Prelude.Show) +mkAnomalyDetectorConfigurationProperty :: + RandomCutForestConfigurationProperty + -> AnomalyDetectorConfigurationProperty +mkAnomalyDetectorConfigurationProperty randomCutForest + = AnomalyDetectorConfigurationProperty + {haddock_workaround_ = (), randomCutForest = randomCutForest} +instance ToResourceProperties AnomalyDetectorConfigurationProperty where + toResourceProperties AnomalyDetectorConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::AnomalyDetector.AnomalyDetectorConfiguration", + supportsTags = Prelude.False, + properties = ["RandomCutForest" JSON..= randomCutForest]} +instance JSON.ToJSON AnomalyDetectorConfigurationProperty where + toJSON AnomalyDetectorConfigurationProperty {..} + = JSON.object ["RandomCutForest" JSON..= randomCutForest] +instance Property "RandomCutForest" AnomalyDetectorConfigurationProperty where + type PropertyType "RandomCutForest" AnomalyDetectorConfigurationProperty = RandomCutForestConfigurationProperty + set newValue AnomalyDetectorConfigurationProperty {..} + = AnomalyDetectorConfigurationProperty + {randomCutForest = newValue, ..} diff --git a/gen/Stratosphere/APS/AnomalyDetector/AnomalyDetectorConfigurationProperty.hs-boot b/gen/Stratosphere/APS/AnomalyDetector/AnomalyDetectorConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/AnomalyDetectorConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.AnomalyDetector.AnomalyDetectorConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AnomalyDetectorConfigurationProperty :: Prelude.Type +instance ToResourceProperties AnomalyDetectorConfigurationProperty +instance Prelude.Eq AnomalyDetectorConfigurationProperty +instance Prelude.Show AnomalyDetectorConfigurationProperty +instance JSON.ToJSON AnomalyDetectorConfigurationProperty diff --git a/gen/Stratosphere/APS/AnomalyDetector/IgnoreNearExpectedProperty.hs b/gen/Stratosphere/APS/AnomalyDetector/IgnoreNearExpectedProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/IgnoreNearExpectedProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.APS.AnomalyDetector.IgnoreNearExpectedProperty ( + IgnoreNearExpectedProperty(..), mkIgnoreNearExpectedProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data IgnoreNearExpectedProperty + = -- | See: + IgnoreNearExpectedProperty {haddock_workaround_ :: (), + -- | See: + amount :: (Prelude.Maybe (Value Prelude.Double)), + -- | See: + ratio :: (Prelude.Maybe (Value Prelude.Double))} + deriving stock (Prelude.Eq, Prelude.Show) +mkIgnoreNearExpectedProperty :: IgnoreNearExpectedProperty +mkIgnoreNearExpectedProperty + = IgnoreNearExpectedProperty + {haddock_workaround_ = (), amount = Prelude.Nothing, + ratio = Prelude.Nothing} +instance ToResourceProperties IgnoreNearExpectedProperty where + toResourceProperties IgnoreNearExpectedProperty {..} + = ResourceProperties + {awsType = "AWS::APS::AnomalyDetector.IgnoreNearExpected", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Amount" Prelude.<$> amount, + (JSON..=) "Ratio" Prelude.<$> ratio])} +instance JSON.ToJSON IgnoreNearExpectedProperty where + toJSON IgnoreNearExpectedProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Amount" Prelude.<$> amount, + (JSON..=) "Ratio" Prelude.<$> ratio])) +instance Property "Amount" IgnoreNearExpectedProperty where + type PropertyType "Amount" IgnoreNearExpectedProperty = Value Prelude.Double + set newValue IgnoreNearExpectedProperty {..} + = IgnoreNearExpectedProperty {amount = Prelude.pure newValue, ..} +instance Property "Ratio" IgnoreNearExpectedProperty where + type PropertyType "Ratio" IgnoreNearExpectedProperty = Value Prelude.Double + set newValue IgnoreNearExpectedProperty {..} + = IgnoreNearExpectedProperty {ratio = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/AnomalyDetector/IgnoreNearExpectedProperty.hs-boot b/gen/Stratosphere/APS/AnomalyDetector/IgnoreNearExpectedProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/IgnoreNearExpectedProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.AnomalyDetector.IgnoreNearExpectedProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data IgnoreNearExpectedProperty :: Prelude.Type +instance ToResourceProperties IgnoreNearExpectedProperty +instance Prelude.Eq IgnoreNearExpectedProperty +instance Prelude.Show IgnoreNearExpectedProperty +instance JSON.ToJSON IgnoreNearExpectedProperty diff --git a/gen/Stratosphere/APS/AnomalyDetector/LabelProperty.hs b/gen/Stratosphere/APS/AnomalyDetector/LabelProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/LabelProperty.hs @@ -0,0 +1,38 @@ +module Stratosphere.APS.AnomalyDetector.LabelProperty ( + LabelProperty(..), mkLabelProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LabelProperty + = -- | See: + LabelProperty {haddock_workaround_ :: (), + -- | See: + key :: (Value Prelude.Text), + -- | See: + value :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkLabelProperty :: + Value Prelude.Text -> Value Prelude.Text -> LabelProperty +mkLabelProperty key value + = LabelProperty + {haddock_workaround_ = (), key = key, value = value} +instance ToResourceProperties LabelProperty where + toResourceProperties LabelProperty {..} + = ResourceProperties + {awsType = "AWS::APS::AnomalyDetector.Label", + supportsTags = Prelude.False, + properties = ["Key" JSON..= key, "Value" JSON..= value]} +instance JSON.ToJSON LabelProperty where + toJSON LabelProperty {..} + = JSON.object ["Key" JSON..= key, "Value" JSON..= value] +instance Property "Key" LabelProperty where + type PropertyType "Key" LabelProperty = Value Prelude.Text + set newValue LabelProperty {..} + = LabelProperty {key = newValue, ..} +instance Property "Value" LabelProperty where + type PropertyType "Value" LabelProperty = Value Prelude.Text + set newValue LabelProperty {..} + = LabelProperty {value = newValue, ..} diff --git a/gen/Stratosphere/APS/AnomalyDetector/LabelProperty.hs-boot b/gen/Stratosphere/APS/AnomalyDetector/LabelProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/LabelProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.AnomalyDetector.LabelProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LabelProperty :: Prelude.Type +instance ToResourceProperties LabelProperty +instance Prelude.Eq LabelProperty +instance Prelude.Show LabelProperty +instance JSON.ToJSON LabelProperty diff --git a/gen/Stratosphere/APS/AnomalyDetector/MissingDataActionProperty.hs b/gen/Stratosphere/APS/AnomalyDetector/MissingDataActionProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/MissingDataActionProperty.hs @@ -0,0 +1,46 @@ +module Stratosphere.APS.AnomalyDetector.MissingDataActionProperty ( + MissingDataActionProperty(..), mkMissingDataActionProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data MissingDataActionProperty + = -- | See: + MissingDataActionProperty {haddock_workaround_ :: (), + -- | See: + markAsAnomaly :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + skip :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkMissingDataActionProperty :: MissingDataActionProperty +mkMissingDataActionProperty + = MissingDataActionProperty + {haddock_workaround_ = (), markAsAnomaly = Prelude.Nothing, + skip = Prelude.Nothing} +instance ToResourceProperties MissingDataActionProperty where + toResourceProperties MissingDataActionProperty {..} + = ResourceProperties + {awsType = "AWS::APS::AnomalyDetector.MissingDataAction", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "MarkAsAnomaly" Prelude.<$> markAsAnomaly, + (JSON..=) "Skip" Prelude.<$> skip])} +instance JSON.ToJSON MissingDataActionProperty where + toJSON MissingDataActionProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "MarkAsAnomaly" Prelude.<$> markAsAnomaly, + (JSON..=) "Skip" Prelude.<$> skip])) +instance Property "MarkAsAnomaly" MissingDataActionProperty where + type PropertyType "MarkAsAnomaly" MissingDataActionProperty = Value Prelude.Bool + set newValue MissingDataActionProperty {..} + = MissingDataActionProperty + {markAsAnomaly = Prelude.pure newValue, ..} +instance Property "Skip" MissingDataActionProperty where + type PropertyType "Skip" MissingDataActionProperty = Value Prelude.Bool + set newValue MissingDataActionProperty {..} + = MissingDataActionProperty {skip = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/AnomalyDetector/MissingDataActionProperty.hs-boot b/gen/Stratosphere/APS/AnomalyDetector/MissingDataActionProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/MissingDataActionProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.AnomalyDetector.MissingDataActionProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data MissingDataActionProperty :: Prelude.Type +instance ToResourceProperties MissingDataActionProperty +instance Prelude.Eq MissingDataActionProperty +instance Prelude.Show MissingDataActionProperty +instance JSON.ToJSON MissingDataActionProperty diff --git a/gen/Stratosphere/APS/AnomalyDetector/RandomCutForestConfigurationProperty.hs b/gen/Stratosphere/APS/AnomalyDetector/RandomCutForestConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/RandomCutForestConfigurationProperty.hs @@ -0,0 +1,84 @@ +module Stratosphere.APS.AnomalyDetector.RandomCutForestConfigurationProperty ( + module Exports, RandomCutForestConfigurationProperty(..), + mkRandomCutForestConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.AnomalyDetector.IgnoreNearExpectedProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RandomCutForestConfigurationProperty + = -- | See: + RandomCutForestConfigurationProperty {haddock_workaround_ :: (), + -- | See: + ignoreNearExpectedFromAbove :: (Prelude.Maybe IgnoreNearExpectedProperty), + -- | See: + ignoreNearExpectedFromBelow :: (Prelude.Maybe IgnoreNearExpectedProperty), + -- | See: + query :: (Value Prelude.Text), + -- | See: + sampleSize :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + shingleSize :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkRandomCutForestConfigurationProperty :: + Value Prelude.Text -> RandomCutForestConfigurationProperty +mkRandomCutForestConfigurationProperty query + = RandomCutForestConfigurationProperty + {haddock_workaround_ = (), query = query, + ignoreNearExpectedFromAbove = Prelude.Nothing, + ignoreNearExpectedFromBelow = Prelude.Nothing, + sampleSize = Prelude.Nothing, shingleSize = Prelude.Nothing} +instance ToResourceProperties RandomCutForestConfigurationProperty where + toResourceProperties RandomCutForestConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::AnomalyDetector.RandomCutForestConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Query" JSON..= query] + (Prelude.catMaybes + [(JSON..=) "IgnoreNearExpectedFromAbove" + Prelude.<$> ignoreNearExpectedFromAbove, + (JSON..=) "IgnoreNearExpectedFromBelow" + Prelude.<$> ignoreNearExpectedFromBelow, + (JSON..=) "SampleSize" Prelude.<$> sampleSize, + (JSON..=) "ShingleSize" Prelude.<$> shingleSize]))} +instance JSON.ToJSON RandomCutForestConfigurationProperty where + toJSON RandomCutForestConfigurationProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Query" JSON..= query] + (Prelude.catMaybes + [(JSON..=) "IgnoreNearExpectedFromAbove" + Prelude.<$> ignoreNearExpectedFromAbove, + (JSON..=) "IgnoreNearExpectedFromBelow" + Prelude.<$> ignoreNearExpectedFromBelow, + (JSON..=) "SampleSize" Prelude.<$> sampleSize, + (JSON..=) "ShingleSize" Prelude.<$> shingleSize]))) +instance Property "IgnoreNearExpectedFromAbove" RandomCutForestConfigurationProperty where + type PropertyType "IgnoreNearExpectedFromAbove" RandomCutForestConfigurationProperty = IgnoreNearExpectedProperty + set newValue RandomCutForestConfigurationProperty {..} + = RandomCutForestConfigurationProperty + {ignoreNearExpectedFromAbove = Prelude.pure newValue, ..} +instance Property "IgnoreNearExpectedFromBelow" RandomCutForestConfigurationProperty where + type PropertyType "IgnoreNearExpectedFromBelow" RandomCutForestConfigurationProperty = IgnoreNearExpectedProperty + set newValue RandomCutForestConfigurationProperty {..} + = RandomCutForestConfigurationProperty + {ignoreNearExpectedFromBelow = Prelude.pure newValue, ..} +instance Property "Query" RandomCutForestConfigurationProperty where + type PropertyType "Query" RandomCutForestConfigurationProperty = Value Prelude.Text + set newValue RandomCutForestConfigurationProperty {..} + = RandomCutForestConfigurationProperty {query = newValue, ..} +instance Property "SampleSize" RandomCutForestConfigurationProperty where + type PropertyType "SampleSize" RandomCutForestConfigurationProperty = Value Prelude.Integer + set newValue RandomCutForestConfigurationProperty {..} + = RandomCutForestConfigurationProperty + {sampleSize = Prelude.pure newValue, ..} +instance Property "ShingleSize" RandomCutForestConfigurationProperty where + type PropertyType "ShingleSize" RandomCutForestConfigurationProperty = Value Prelude.Integer + set newValue RandomCutForestConfigurationProperty {..} + = RandomCutForestConfigurationProperty + {shingleSize = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/AnomalyDetector/RandomCutForestConfigurationProperty.hs-boot b/gen/Stratosphere/APS/AnomalyDetector/RandomCutForestConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/AnomalyDetector/RandomCutForestConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.AnomalyDetector.RandomCutForestConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RandomCutForestConfigurationProperty :: Prelude.Type +instance ToResourceProperties RandomCutForestConfigurationProperty +instance Prelude.Eq RandomCutForestConfigurationProperty +instance Prelude.Show RandomCutForestConfigurationProperty +instance JSON.ToJSON RandomCutForestConfigurationProperty diff --git a/gen/Stratosphere/APS/ResourcePolicy.hs b/gen/Stratosphere/APS/ResourcePolicy.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/ResourcePolicy.hs @@ -0,0 +1,42 @@ +module Stratosphere.APS.ResourcePolicy ( + ResourcePolicy(..), mkResourcePolicy + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ResourcePolicy + = -- | See: + ResourcePolicy {haddock_workaround_ :: (), + -- | See: + policyDocument :: (Value Prelude.Text), + -- | See: + workspaceArn :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkResourcePolicy :: + Value Prelude.Text -> Value Prelude.Text -> ResourcePolicy +mkResourcePolicy policyDocument workspaceArn + = ResourcePolicy + {haddock_workaround_ = (), policyDocument = policyDocument, + workspaceArn = workspaceArn} +instance ToResourceProperties ResourcePolicy where + toResourceProperties ResourcePolicy {..} + = ResourceProperties + {awsType = "AWS::APS::ResourcePolicy", + supportsTags = Prelude.False, + properties = ["PolicyDocument" JSON..= policyDocument, + "WorkspaceArn" JSON..= workspaceArn]} +instance JSON.ToJSON ResourcePolicy where + toJSON ResourcePolicy {..} + = JSON.object + ["PolicyDocument" JSON..= policyDocument, + "WorkspaceArn" JSON..= workspaceArn] +instance Property "PolicyDocument" ResourcePolicy where + type PropertyType "PolicyDocument" ResourcePolicy = Value Prelude.Text + set newValue ResourcePolicy {..} + = ResourcePolicy {policyDocument = newValue, ..} +instance Property "WorkspaceArn" ResourcePolicy where + type PropertyType "WorkspaceArn" ResourcePolicy = Value Prelude.Text + set newValue ResourcePolicy {..} + = ResourcePolicy {workspaceArn = newValue, ..} diff --git a/gen/Stratosphere/APS/RuleGroupsNamespace.hs b/gen/Stratosphere/APS/RuleGroupsNamespace.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/RuleGroupsNamespace.hs @@ -0,0 +1,62 @@ +module Stratosphere.APS.RuleGroupsNamespace ( + RuleGroupsNamespace(..), mkRuleGroupsNamespace + ) 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 RuleGroupsNamespace + = -- | See: + RuleGroupsNamespace {haddock_workaround_ :: (), + -- | See: + data' :: (Value Prelude.Text), + -- | See: + name :: (Value Prelude.Text), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + workspace :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkRuleGroupsNamespace :: + Value Prelude.Text + -> Value Prelude.Text -> Value Prelude.Text -> RuleGroupsNamespace +mkRuleGroupsNamespace data' name workspace + = RuleGroupsNamespace + {haddock_workaround_ = (), data' = data', name = name, + workspace = workspace, tags = Prelude.Nothing} +instance ToResourceProperties RuleGroupsNamespace where + toResourceProperties RuleGroupsNamespace {..} + = ResourceProperties + {awsType = "AWS::APS::RuleGroupsNamespace", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Data" JSON..= data', "Name" JSON..= name, + "Workspace" JSON..= workspace] + (Prelude.catMaybes [(JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON RuleGroupsNamespace where + toJSON RuleGroupsNamespace {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Data" JSON..= data', "Name" JSON..= name, + "Workspace" JSON..= workspace] + (Prelude.catMaybes [(JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "Data" RuleGroupsNamespace where + type PropertyType "Data" RuleGroupsNamespace = Value Prelude.Text + set newValue RuleGroupsNamespace {..} + = RuleGroupsNamespace {data' = newValue, ..} +instance Property "Name" RuleGroupsNamespace where + type PropertyType "Name" RuleGroupsNamespace = Value Prelude.Text + set newValue RuleGroupsNamespace {..} + = RuleGroupsNamespace {name = newValue, ..} +instance Property "Tags" RuleGroupsNamespace where + type PropertyType "Tags" RuleGroupsNamespace = [Tag] + set newValue RuleGroupsNamespace {..} + = RuleGroupsNamespace {tags = Prelude.pure newValue, ..} +instance Property "Workspace" RuleGroupsNamespace where + type PropertyType "Workspace" RuleGroupsNamespace = Value Prelude.Text + set newValue RuleGroupsNamespace {..} + = RuleGroupsNamespace {workspace = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper.hs b/gen/Stratosphere/APS/Scraper.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper.hs @@ -0,0 +1,97 @@ +module Stratosphere.APS.Scraper ( + module Exports, Scraper(..), mkScraper + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Scraper.DestinationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Scraper.RoleConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Scraper.ScrapeConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Scraper.ScraperLoggingConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Scraper.SourceProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data Scraper + = -- | See: + Scraper {haddock_workaround_ :: (), + -- | See: + alias :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + destination :: DestinationProperty, + -- | See: + roleConfiguration :: (Prelude.Maybe RoleConfigurationProperty), + -- | See: + scrapeConfiguration :: ScrapeConfigurationProperty, + -- | See: + scraperLoggingConfiguration :: (Prelude.Maybe ScraperLoggingConfigurationProperty), + -- | See: + source :: SourceProperty, + -- | See: + tags :: (Prelude.Maybe [Tag])} + deriving stock (Prelude.Eq, Prelude.Show) +mkScraper :: + DestinationProperty + -> ScrapeConfigurationProperty -> SourceProperty -> Scraper +mkScraper destination scrapeConfiguration source + = Scraper + {haddock_workaround_ = (), destination = destination, + scrapeConfiguration = scrapeConfiguration, source = source, + alias = Prelude.Nothing, roleConfiguration = Prelude.Nothing, + scraperLoggingConfiguration = Prelude.Nothing, + tags = Prelude.Nothing} +instance ToResourceProperties Scraper where + toResourceProperties Scraper {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Destination" JSON..= destination, + "ScrapeConfiguration" JSON..= scrapeConfiguration, + "Source" JSON..= source] + (Prelude.catMaybes + [(JSON..=) "Alias" Prelude.<$> alias, + (JSON..=) "RoleConfiguration" Prelude.<$> roleConfiguration, + (JSON..=) "ScraperLoggingConfiguration" + Prelude.<$> scraperLoggingConfiguration, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON Scraper where + toJSON Scraper {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Destination" JSON..= destination, + "ScrapeConfiguration" JSON..= scrapeConfiguration, + "Source" JSON..= source] + (Prelude.catMaybes + [(JSON..=) "Alias" Prelude.<$> alias, + (JSON..=) "RoleConfiguration" Prelude.<$> roleConfiguration, + (JSON..=) "ScraperLoggingConfiguration" + Prelude.<$> scraperLoggingConfiguration, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "Alias" Scraper where + type PropertyType "Alias" Scraper = Value Prelude.Text + set newValue Scraper {..} + = Scraper {alias = Prelude.pure newValue, ..} +instance Property "Destination" Scraper where + type PropertyType "Destination" Scraper = DestinationProperty + set newValue Scraper {..} = Scraper {destination = newValue, ..} +instance Property "RoleConfiguration" Scraper where + type PropertyType "RoleConfiguration" Scraper = RoleConfigurationProperty + set newValue Scraper {..} + = Scraper {roleConfiguration = Prelude.pure newValue, ..} +instance Property "ScrapeConfiguration" Scraper where + type PropertyType "ScrapeConfiguration" Scraper = ScrapeConfigurationProperty + set newValue Scraper {..} + = Scraper {scrapeConfiguration = newValue, ..} +instance Property "ScraperLoggingConfiguration" Scraper where + type PropertyType "ScraperLoggingConfiguration" Scraper = ScraperLoggingConfigurationProperty + set newValue Scraper {..} + = Scraper {scraperLoggingConfiguration = Prelude.pure newValue, ..} +instance Property "Source" Scraper where + type PropertyType "Source" Scraper = SourceProperty + set newValue Scraper {..} = Scraper {source = newValue, ..} +instance Property "Tags" Scraper where + type PropertyType "Tags" Scraper = [Tag] + set newValue Scraper {..} + = Scraper {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/AmpConfigurationProperty.hs b/gen/Stratosphere/APS/Scraper/AmpConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/AmpConfigurationProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.APS.Scraper.AmpConfigurationProperty ( + AmpConfigurationProperty(..), mkAmpConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AmpConfigurationProperty + = -- | See: + AmpConfigurationProperty {haddock_workaround_ :: (), + -- | See: + workspaceArn :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkAmpConfigurationProperty :: + Value Prelude.Text -> AmpConfigurationProperty +mkAmpConfigurationProperty workspaceArn + = AmpConfigurationProperty + {haddock_workaround_ = (), workspaceArn = workspaceArn} +instance ToResourceProperties AmpConfigurationProperty where + toResourceProperties AmpConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.AmpConfiguration", + supportsTags = Prelude.False, + properties = ["WorkspaceArn" JSON..= workspaceArn]} +instance JSON.ToJSON AmpConfigurationProperty where + toJSON AmpConfigurationProperty {..} + = JSON.object ["WorkspaceArn" JSON..= workspaceArn] +instance Property "WorkspaceArn" AmpConfigurationProperty where + type PropertyType "WorkspaceArn" AmpConfigurationProperty = Value Prelude.Text + set newValue AmpConfigurationProperty {..} + = AmpConfigurationProperty {workspaceArn = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/AmpConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/AmpConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/AmpConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.AmpConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AmpConfigurationProperty :: Prelude.Type +instance ToResourceProperties AmpConfigurationProperty +instance Prelude.Eq AmpConfigurationProperty +instance Prelude.Show AmpConfigurationProperty +instance JSON.ToJSON AmpConfigurationProperty diff --git a/gen/Stratosphere/APS/Scraper/CloudWatchLogDestinationProperty.hs b/gen/Stratosphere/APS/Scraper/CloudWatchLogDestinationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/CloudWatchLogDestinationProperty.hs @@ -0,0 +1,39 @@ +module Stratosphere.APS.Scraper.CloudWatchLogDestinationProperty ( + CloudWatchLogDestinationProperty(..), + mkCloudWatchLogDestinationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data CloudWatchLogDestinationProperty + = -- | See: + CloudWatchLogDestinationProperty {haddock_workaround_ :: (), + -- | See: + logGroupArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkCloudWatchLogDestinationProperty :: + CloudWatchLogDestinationProperty +mkCloudWatchLogDestinationProperty + = CloudWatchLogDestinationProperty + {haddock_workaround_ = (), logGroupArn = Prelude.Nothing} +instance ToResourceProperties CloudWatchLogDestinationProperty where + toResourceProperties CloudWatchLogDestinationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.CloudWatchLogDestination", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupArn" Prelude.<$> logGroupArn])} +instance JSON.ToJSON CloudWatchLogDestinationProperty where + toJSON CloudWatchLogDestinationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupArn" Prelude.<$> logGroupArn])) +instance Property "LogGroupArn" CloudWatchLogDestinationProperty where + type PropertyType "LogGroupArn" CloudWatchLogDestinationProperty = Value Prelude.Text + set newValue CloudWatchLogDestinationProperty {..} + = CloudWatchLogDestinationProperty + {logGroupArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/CloudWatchLogDestinationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/CloudWatchLogDestinationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/CloudWatchLogDestinationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.CloudWatchLogDestinationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data CloudWatchLogDestinationProperty :: Prelude.Type +instance ToResourceProperties CloudWatchLogDestinationProperty +instance Prelude.Eq CloudWatchLogDestinationProperty +instance Prelude.Show CloudWatchLogDestinationProperty +instance JSON.ToJSON CloudWatchLogDestinationProperty diff --git a/gen/Stratosphere/APS/Scraper/ComponentConfigProperty.hs b/gen/Stratosphere/APS/Scraper/ComponentConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ComponentConfigProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.APS.Scraper.ComponentConfigProperty ( + ComponentConfigProperty(..), mkComponentConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ComponentConfigProperty + = -- | See: + ComponentConfigProperty {haddock_workaround_ :: (), + -- | See: + options :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text)))} + deriving stock (Prelude.Eq, Prelude.Show) +mkComponentConfigProperty :: ComponentConfigProperty +mkComponentConfigProperty + = ComponentConfigProperty + {haddock_workaround_ = (), options = Prelude.Nothing} +instance ToResourceProperties ComponentConfigProperty where + toResourceProperties ComponentConfigProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.ComponentConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Options" Prelude.<$> options])} +instance JSON.ToJSON ComponentConfigProperty where + toJSON ComponentConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Options" Prelude.<$> options])) +instance Property "Options" ComponentConfigProperty where + type PropertyType "Options" ComponentConfigProperty = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue ComponentConfigProperty {..} + = ComponentConfigProperty {options = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/ComponentConfigProperty.hs-boot b/gen/Stratosphere/APS/Scraper/ComponentConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ComponentConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.ComponentConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ComponentConfigProperty :: Prelude.Type +instance ToResourceProperties ComponentConfigProperty +instance Prelude.Eq ComponentConfigProperty +instance Prelude.Show ComponentConfigProperty +instance JSON.ToJSON ComponentConfigProperty diff --git a/gen/Stratosphere/APS/Scraper/DestinationProperty.hs b/gen/Stratosphere/APS/Scraper/DestinationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/DestinationProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.APS.Scraper.DestinationProperty ( + module Exports, DestinationProperty(..), mkDestinationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Scraper.AmpConfigurationProperty as Exports +import Stratosphere.ResourceProperties +data DestinationProperty + = -- | See: + DestinationProperty {haddock_workaround_ :: (), + -- | See: + ampConfiguration :: AmpConfigurationProperty} + deriving stock (Prelude.Eq, Prelude.Show) +mkDestinationProperty :: + AmpConfigurationProperty -> DestinationProperty +mkDestinationProperty ampConfiguration + = DestinationProperty + {haddock_workaround_ = (), ampConfiguration = ampConfiguration} +instance ToResourceProperties DestinationProperty where + toResourceProperties DestinationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.Destination", + supportsTags = Prelude.False, + properties = ["AmpConfiguration" JSON..= ampConfiguration]} +instance JSON.ToJSON DestinationProperty where + toJSON DestinationProperty {..} + = JSON.object ["AmpConfiguration" JSON..= ampConfiguration] +instance Property "AmpConfiguration" DestinationProperty where + type PropertyType "AmpConfiguration" DestinationProperty = AmpConfigurationProperty + set newValue DestinationProperty {..} + = DestinationProperty {ampConfiguration = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/DestinationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/DestinationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/DestinationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.DestinationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data DestinationProperty :: Prelude.Type +instance ToResourceProperties DestinationProperty +instance Prelude.Eq DestinationProperty +instance Prelude.Show DestinationProperty +instance JSON.ToJSON DestinationProperty diff --git a/gen/Stratosphere/APS/Scraper/EksConfigurationProperty.hs b/gen/Stratosphere/APS/Scraper/EksConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/EksConfigurationProperty.hs @@ -0,0 +1,56 @@ +module Stratosphere.APS.Scraper.EksConfigurationProperty ( + EksConfigurationProperty(..), mkEksConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EksConfigurationProperty + = -- | See: + EksConfigurationProperty {haddock_workaround_ :: (), + -- | See: + clusterArn :: (Value Prelude.Text), + -- | See: + securityGroupIds :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + subnetIds :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkEksConfigurationProperty :: + Value Prelude.Text + -> ValueList Prelude.Text -> EksConfigurationProperty +mkEksConfigurationProperty clusterArn subnetIds + = EksConfigurationProperty + {haddock_workaround_ = (), clusterArn = clusterArn, + subnetIds = subnetIds, securityGroupIds = Prelude.Nothing} +instance ToResourceProperties EksConfigurationProperty where + toResourceProperties EksConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.EksConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ClusterArn" JSON..= clusterArn, "SubnetIds" JSON..= subnetIds] + (Prelude.catMaybes + [(JSON..=) "SecurityGroupIds" Prelude.<$> securityGroupIds]))} +instance JSON.ToJSON EksConfigurationProperty where + toJSON EksConfigurationProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClusterArn" JSON..= clusterArn, "SubnetIds" JSON..= subnetIds] + (Prelude.catMaybes + [(JSON..=) "SecurityGroupIds" Prelude.<$> securityGroupIds]))) +instance Property "ClusterArn" EksConfigurationProperty where + type PropertyType "ClusterArn" EksConfigurationProperty = Value Prelude.Text + set newValue EksConfigurationProperty {..} + = EksConfigurationProperty {clusterArn = newValue, ..} +instance Property "SecurityGroupIds" EksConfigurationProperty where + type PropertyType "SecurityGroupIds" EksConfigurationProperty = ValueList Prelude.Text + set newValue EksConfigurationProperty {..} + = EksConfigurationProperty + {securityGroupIds = Prelude.pure newValue, ..} +instance Property "SubnetIds" EksConfigurationProperty where + type PropertyType "SubnetIds" EksConfigurationProperty = ValueList Prelude.Text + set newValue EksConfigurationProperty {..} + = EksConfigurationProperty {subnetIds = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/EksConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/EksConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/EksConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.EksConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EksConfigurationProperty :: Prelude.Type +instance ToResourceProperties EksConfigurationProperty +instance Prelude.Eq EksConfigurationProperty +instance Prelude.Show EksConfigurationProperty +instance JSON.ToJSON EksConfigurationProperty diff --git a/gen/Stratosphere/APS/Scraper/RoleConfigurationProperty.hs b/gen/Stratosphere/APS/Scraper/RoleConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/RoleConfigurationProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.APS.Scraper.RoleConfigurationProperty ( + RoleConfigurationProperty(..), mkRoleConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RoleConfigurationProperty + = -- | See: + RoleConfigurationProperty {haddock_workaround_ :: (), + -- | See: + sourceRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + targetRoleArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkRoleConfigurationProperty :: RoleConfigurationProperty +mkRoleConfigurationProperty + = RoleConfigurationProperty + {haddock_workaround_ = (), sourceRoleArn = Prelude.Nothing, + targetRoleArn = Prelude.Nothing} +instance ToResourceProperties RoleConfigurationProperty where + toResourceProperties RoleConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.RoleConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SourceRoleArn" Prelude.<$> sourceRoleArn, + (JSON..=) "TargetRoleArn" Prelude.<$> targetRoleArn])} +instance JSON.ToJSON RoleConfigurationProperty where + toJSON RoleConfigurationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SourceRoleArn" Prelude.<$> sourceRoleArn, + (JSON..=) "TargetRoleArn" Prelude.<$> targetRoleArn])) +instance Property "SourceRoleArn" RoleConfigurationProperty where + type PropertyType "SourceRoleArn" RoleConfigurationProperty = Value Prelude.Text + set newValue RoleConfigurationProperty {..} + = RoleConfigurationProperty + {sourceRoleArn = Prelude.pure newValue, ..} +instance Property "TargetRoleArn" RoleConfigurationProperty where + type PropertyType "TargetRoleArn" RoleConfigurationProperty = Value Prelude.Text + set newValue RoleConfigurationProperty {..} + = RoleConfigurationProperty + {targetRoleArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/RoleConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/RoleConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/RoleConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.RoleConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RoleConfigurationProperty :: Prelude.Type +instance ToResourceProperties RoleConfigurationProperty +instance Prelude.Eq RoleConfigurationProperty +instance Prelude.Show RoleConfigurationProperty +instance JSON.ToJSON RoleConfigurationProperty diff --git a/gen/Stratosphere/APS/Scraper/ScrapeConfigurationProperty.hs b/gen/Stratosphere/APS/Scraper/ScrapeConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScrapeConfigurationProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.APS.Scraper.ScrapeConfigurationProperty ( + ScrapeConfigurationProperty(..), mkScrapeConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ScrapeConfigurationProperty + = -- | See: + ScrapeConfigurationProperty {haddock_workaround_ :: (), + -- | See: + configurationBlob :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkScrapeConfigurationProperty :: + Value Prelude.Text -> ScrapeConfigurationProperty +mkScrapeConfigurationProperty configurationBlob + = ScrapeConfigurationProperty + {haddock_workaround_ = (), configurationBlob = configurationBlob} +instance ToResourceProperties ScrapeConfigurationProperty where + toResourceProperties ScrapeConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.ScrapeConfiguration", + supportsTags = Prelude.False, + properties = ["ConfigurationBlob" JSON..= configurationBlob]} +instance JSON.ToJSON ScrapeConfigurationProperty where + toJSON ScrapeConfigurationProperty {..} + = JSON.object ["ConfigurationBlob" JSON..= configurationBlob] +instance Property "ConfigurationBlob" ScrapeConfigurationProperty where + type PropertyType "ConfigurationBlob" ScrapeConfigurationProperty = Value Prelude.Text + set newValue ScrapeConfigurationProperty {..} + = ScrapeConfigurationProperty {configurationBlob = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/ScrapeConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/ScrapeConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScrapeConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.ScrapeConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ScrapeConfigurationProperty :: Prelude.Type +instance ToResourceProperties ScrapeConfigurationProperty +instance Prelude.Eq ScrapeConfigurationProperty +instance Prelude.Show ScrapeConfigurationProperty +instance JSON.ToJSON ScrapeConfigurationProperty diff --git a/gen/Stratosphere/APS/Scraper/ScraperComponentProperty.hs b/gen/Stratosphere/APS/Scraper/ScraperComponentProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScraperComponentProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.APS.Scraper.ScraperComponentProperty ( + module Exports, ScraperComponentProperty(..), + mkScraperComponentProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Scraper.ComponentConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ScraperComponentProperty + = -- | See: + ScraperComponentProperty {haddock_workaround_ :: (), + -- | See: + config :: (Prelude.Maybe ComponentConfigProperty), + -- | See: + type' :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkScraperComponentProperty :: + Value Prelude.Text -> ScraperComponentProperty +mkScraperComponentProperty type' + = ScraperComponentProperty + {haddock_workaround_ = (), type' = type', config = Prelude.Nothing} +instance ToResourceProperties ScraperComponentProperty where + toResourceProperties ScraperComponentProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.ScraperComponent", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes [(JSON..=) "Config" Prelude.<$> config]))} +instance JSON.ToJSON ScraperComponentProperty where + toJSON ScraperComponentProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes [(JSON..=) "Config" Prelude.<$> config]))) +instance Property "Config" ScraperComponentProperty where + type PropertyType "Config" ScraperComponentProperty = ComponentConfigProperty + set newValue ScraperComponentProperty {..} + = ScraperComponentProperty {config = Prelude.pure newValue, ..} +instance Property "Type" ScraperComponentProperty where + type PropertyType "Type" ScraperComponentProperty = Value Prelude.Text + set newValue ScraperComponentProperty {..} + = ScraperComponentProperty {type' = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/ScraperComponentProperty.hs-boot b/gen/Stratosphere/APS/Scraper/ScraperComponentProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScraperComponentProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.ScraperComponentProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ScraperComponentProperty :: Prelude.Type +instance ToResourceProperties ScraperComponentProperty +instance Prelude.Eq ScraperComponentProperty +instance Prelude.Show ScraperComponentProperty +instance JSON.ToJSON ScraperComponentProperty diff --git a/gen/Stratosphere/APS/Scraper/ScraperLoggingConfigurationProperty.hs b/gen/Stratosphere/APS/Scraper/ScraperLoggingConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScraperLoggingConfigurationProperty.hs @@ -0,0 +1,50 @@ +module Stratosphere.APS.Scraper.ScraperLoggingConfigurationProperty ( + module Exports, ScraperLoggingConfigurationProperty(..), + mkScraperLoggingConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Scraper.ScraperComponentProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Scraper.ScraperLoggingDestinationProperty as Exports +import Stratosphere.ResourceProperties +data ScraperLoggingConfigurationProperty + = -- | See: + ScraperLoggingConfigurationProperty {haddock_workaround_ :: (), + -- | See: + loggingDestination :: ScraperLoggingDestinationProperty, + -- | See: + scraperComponents :: [ScraperComponentProperty]} + deriving stock (Prelude.Eq, Prelude.Show) +mkScraperLoggingConfigurationProperty :: + ScraperLoggingDestinationProperty + -> [ScraperComponentProperty] + -> ScraperLoggingConfigurationProperty +mkScraperLoggingConfigurationProperty + loggingDestination + scraperComponents + = ScraperLoggingConfigurationProperty + {haddock_workaround_ = (), loggingDestination = loggingDestination, + scraperComponents = scraperComponents} +instance ToResourceProperties ScraperLoggingConfigurationProperty where + toResourceProperties ScraperLoggingConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.ScraperLoggingConfiguration", + supportsTags = Prelude.False, + properties = ["LoggingDestination" JSON..= loggingDestination, + "ScraperComponents" JSON..= scraperComponents]} +instance JSON.ToJSON ScraperLoggingConfigurationProperty where + toJSON ScraperLoggingConfigurationProperty {..} + = JSON.object + ["LoggingDestination" JSON..= loggingDestination, + "ScraperComponents" JSON..= scraperComponents] +instance Property "LoggingDestination" ScraperLoggingConfigurationProperty where + type PropertyType "LoggingDestination" ScraperLoggingConfigurationProperty = ScraperLoggingDestinationProperty + set newValue ScraperLoggingConfigurationProperty {..} + = ScraperLoggingConfigurationProperty + {loggingDestination = newValue, ..} +instance Property "ScraperComponents" ScraperLoggingConfigurationProperty where + type PropertyType "ScraperComponents" ScraperLoggingConfigurationProperty = [ScraperComponentProperty] + set newValue ScraperLoggingConfigurationProperty {..} + = ScraperLoggingConfigurationProperty + {scraperComponents = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/ScraperLoggingConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/ScraperLoggingConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScraperLoggingConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.ScraperLoggingConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ScraperLoggingConfigurationProperty :: Prelude.Type +instance ToResourceProperties ScraperLoggingConfigurationProperty +instance Prelude.Eq ScraperLoggingConfigurationProperty +instance Prelude.Show ScraperLoggingConfigurationProperty +instance JSON.ToJSON ScraperLoggingConfigurationProperty diff --git a/gen/Stratosphere/APS/Scraper/ScraperLoggingDestinationProperty.hs b/gen/Stratosphere/APS/Scraper/ScraperLoggingDestinationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScraperLoggingDestinationProperty.hs @@ -0,0 +1,39 @@ +module Stratosphere.APS.Scraper.ScraperLoggingDestinationProperty ( + module Exports, ScraperLoggingDestinationProperty(..), + mkScraperLoggingDestinationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Scraper.CloudWatchLogDestinationProperty as Exports +import Stratosphere.ResourceProperties +data ScraperLoggingDestinationProperty + = -- | See: + ScraperLoggingDestinationProperty {haddock_workaround_ :: (), + -- | See: + cloudWatchLogs :: (Prelude.Maybe CloudWatchLogDestinationProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkScraperLoggingDestinationProperty :: + ScraperLoggingDestinationProperty +mkScraperLoggingDestinationProperty + = ScraperLoggingDestinationProperty + {haddock_workaround_ = (), cloudWatchLogs = Prelude.Nothing} +instance ToResourceProperties ScraperLoggingDestinationProperty where + toResourceProperties ScraperLoggingDestinationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.ScraperLoggingDestination", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CloudWatchLogs" Prelude.<$> cloudWatchLogs])} +instance JSON.ToJSON ScraperLoggingDestinationProperty where + toJSON ScraperLoggingDestinationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CloudWatchLogs" Prelude.<$> cloudWatchLogs])) +instance Property "CloudWatchLogs" ScraperLoggingDestinationProperty where + type PropertyType "CloudWatchLogs" ScraperLoggingDestinationProperty = CloudWatchLogDestinationProperty + set newValue ScraperLoggingDestinationProperty {..} + = ScraperLoggingDestinationProperty + {cloudWatchLogs = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/ScraperLoggingDestinationProperty.hs-boot b/gen/Stratosphere/APS/Scraper/ScraperLoggingDestinationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/ScraperLoggingDestinationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.ScraperLoggingDestinationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ScraperLoggingDestinationProperty :: Prelude.Type +instance ToResourceProperties ScraperLoggingDestinationProperty +instance Prelude.Eq ScraperLoggingDestinationProperty +instance Prelude.Show ScraperLoggingDestinationProperty +instance JSON.ToJSON ScraperLoggingDestinationProperty diff --git a/gen/Stratosphere/APS/Scraper/SourceProperty.hs b/gen/Stratosphere/APS/Scraper/SourceProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/SourceProperty.hs @@ -0,0 +1,31 @@ +module Stratosphere.APS.Scraper.SourceProperty ( + module Exports, SourceProperty(..), mkSourceProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Scraper.EksConfigurationProperty as Exports +import Stratosphere.ResourceProperties +data SourceProperty + = -- | See: + SourceProperty {haddock_workaround_ :: (), + -- | See: + eksConfiguration :: EksConfigurationProperty} + deriving stock (Prelude.Eq, Prelude.Show) +mkSourceProperty :: EksConfigurationProperty -> SourceProperty +mkSourceProperty eksConfiguration + = SourceProperty + {haddock_workaround_ = (), eksConfiguration = eksConfiguration} +instance ToResourceProperties SourceProperty where + toResourceProperties SourceProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Scraper.Source", + supportsTags = Prelude.False, + properties = ["EksConfiguration" JSON..= eksConfiguration]} +instance JSON.ToJSON SourceProperty where + toJSON SourceProperty {..} + = JSON.object ["EksConfiguration" JSON..= eksConfiguration] +instance Property "EksConfiguration" SourceProperty where + type PropertyType "EksConfiguration" SourceProperty = EksConfigurationProperty + set newValue SourceProperty {..} + = SourceProperty {eksConfiguration = newValue, ..} diff --git a/gen/Stratosphere/APS/Scraper/SourceProperty.hs-boot b/gen/Stratosphere/APS/Scraper/SourceProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Scraper/SourceProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Scraper.SourceProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data SourceProperty :: Prelude.Type +instance ToResourceProperties SourceProperty +instance Prelude.Eq SourceProperty +instance Prelude.Show SourceProperty +instance JSON.ToJSON SourceProperty diff --git a/gen/Stratosphere/APS/Workspace.hs b/gen/Stratosphere/APS/Workspace.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace.hs @@ -0,0 +1,98 @@ +module Stratosphere.APS.Workspace ( + module Exports, Workspace(..), mkWorkspace + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Workspace.LoggingConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Workspace.QueryLoggingConfigurationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Workspace.WorkspaceConfigurationProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data Workspace + = -- | See: + Workspace {haddock_workaround_ :: (), + -- | See: + alertManagerDefinition :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + alias :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + kmsKeyArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + loggingConfiguration :: (Prelude.Maybe LoggingConfigurationProperty), + -- | See: + queryLoggingConfiguration :: (Prelude.Maybe QueryLoggingConfigurationProperty), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + workspaceConfiguration :: (Prelude.Maybe WorkspaceConfigurationProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkWorkspace :: Workspace +mkWorkspace + = Workspace + {haddock_workaround_ = (), + alertManagerDefinition = Prelude.Nothing, alias = Prelude.Nothing, + kmsKeyArn = Prelude.Nothing, + loggingConfiguration = Prelude.Nothing, + queryLoggingConfiguration = Prelude.Nothing, + tags = Prelude.Nothing, workspaceConfiguration = Prelude.Nothing} +instance ToResourceProperties Workspace where + toResourceProperties Workspace {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace", supportsTags = Prelude.True, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AlertManagerDefinition" + Prelude.<$> alertManagerDefinition, + (JSON..=) "Alias" Prelude.<$> alias, + (JSON..=) "KmsKeyArn" Prelude.<$> kmsKeyArn, + (JSON..=) "LoggingConfiguration" Prelude.<$> loggingConfiguration, + (JSON..=) "QueryLoggingConfiguration" + Prelude.<$> queryLoggingConfiguration, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "WorkspaceConfiguration" + Prelude.<$> workspaceConfiguration])} +instance JSON.ToJSON Workspace where + toJSON Workspace {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AlertManagerDefinition" + Prelude.<$> alertManagerDefinition, + (JSON..=) "Alias" Prelude.<$> alias, + (JSON..=) "KmsKeyArn" Prelude.<$> kmsKeyArn, + (JSON..=) "LoggingConfiguration" Prelude.<$> loggingConfiguration, + (JSON..=) "QueryLoggingConfiguration" + Prelude.<$> queryLoggingConfiguration, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "WorkspaceConfiguration" + Prelude.<$> workspaceConfiguration])) +instance Property "AlertManagerDefinition" Workspace where + type PropertyType "AlertManagerDefinition" Workspace = Value Prelude.Text + set newValue Workspace {..} + = Workspace {alertManagerDefinition = Prelude.pure newValue, ..} +instance Property "Alias" Workspace where + type PropertyType "Alias" Workspace = Value Prelude.Text + set newValue Workspace {..} + = Workspace {alias = Prelude.pure newValue, ..} +instance Property "KmsKeyArn" Workspace where + type PropertyType "KmsKeyArn" Workspace = Value Prelude.Text + set newValue Workspace {..} + = Workspace {kmsKeyArn = Prelude.pure newValue, ..} +instance Property "LoggingConfiguration" Workspace where + type PropertyType "LoggingConfiguration" Workspace = LoggingConfigurationProperty + set newValue Workspace {..} + = Workspace {loggingConfiguration = Prelude.pure newValue, ..} +instance Property "QueryLoggingConfiguration" Workspace where + type PropertyType "QueryLoggingConfiguration" Workspace = QueryLoggingConfigurationProperty + set newValue Workspace {..} + = Workspace {queryLoggingConfiguration = Prelude.pure newValue, ..} +instance Property "Tags" Workspace where + type PropertyType "Tags" Workspace = [Tag] + set newValue Workspace {..} + = Workspace {tags = Prelude.pure newValue, ..} +instance Property "WorkspaceConfiguration" Workspace where + type PropertyType "WorkspaceConfiguration" Workspace = WorkspaceConfigurationProperty + set newValue Workspace {..} + = Workspace {workspaceConfiguration = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/CloudWatchLogDestinationProperty.hs b/gen/Stratosphere/APS/Workspace/CloudWatchLogDestinationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/CloudWatchLogDestinationProperty.hs @@ -0,0 +1,33 @@ +module Stratosphere.APS.Workspace.CloudWatchLogDestinationProperty ( + CloudWatchLogDestinationProperty(..), + mkCloudWatchLogDestinationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data CloudWatchLogDestinationProperty + = -- | See: + CloudWatchLogDestinationProperty {haddock_workaround_ :: (), + -- | See: + logGroupArn :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkCloudWatchLogDestinationProperty :: + Value Prelude.Text -> CloudWatchLogDestinationProperty +mkCloudWatchLogDestinationProperty logGroupArn + = CloudWatchLogDestinationProperty + {haddock_workaround_ = (), logGroupArn = logGroupArn} +instance ToResourceProperties CloudWatchLogDestinationProperty where + toResourceProperties CloudWatchLogDestinationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.CloudWatchLogDestination", + supportsTags = Prelude.False, + properties = ["LogGroupArn" JSON..= logGroupArn]} +instance JSON.ToJSON CloudWatchLogDestinationProperty where + toJSON CloudWatchLogDestinationProperty {..} + = JSON.object ["LogGroupArn" JSON..= logGroupArn] +instance Property "LogGroupArn" CloudWatchLogDestinationProperty where + type PropertyType "LogGroupArn" CloudWatchLogDestinationProperty = Value Prelude.Text + set newValue CloudWatchLogDestinationProperty {..} + = CloudWatchLogDestinationProperty {logGroupArn = newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/CloudWatchLogDestinationProperty.hs-boot b/gen/Stratosphere/APS/Workspace/CloudWatchLogDestinationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/CloudWatchLogDestinationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.CloudWatchLogDestinationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data CloudWatchLogDestinationProperty :: Prelude.Type +instance ToResourceProperties CloudWatchLogDestinationProperty +instance Prelude.Eq CloudWatchLogDestinationProperty +instance Prelude.Show CloudWatchLogDestinationProperty +instance JSON.ToJSON CloudWatchLogDestinationProperty diff --git a/gen/Stratosphere/APS/Workspace/LabelProperty.hs b/gen/Stratosphere/APS/Workspace/LabelProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LabelProperty.hs @@ -0,0 +1,38 @@ +module Stratosphere.APS.Workspace.LabelProperty ( + LabelProperty(..), mkLabelProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LabelProperty + = -- | See: + LabelProperty {haddock_workaround_ :: (), + -- | See: + name :: (Value Prelude.Text), + -- | See: + value :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkLabelProperty :: + Value Prelude.Text -> Value Prelude.Text -> LabelProperty +mkLabelProperty name value + = LabelProperty + {haddock_workaround_ = (), name = name, value = value} +instance ToResourceProperties LabelProperty where + toResourceProperties LabelProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.Label", + supportsTags = Prelude.False, + properties = ["Name" JSON..= name, "Value" JSON..= value]} +instance JSON.ToJSON LabelProperty where + toJSON LabelProperty {..} + = JSON.object ["Name" JSON..= name, "Value" JSON..= value] +instance Property "Name" LabelProperty where + type PropertyType "Name" LabelProperty = Value Prelude.Text + set newValue LabelProperty {..} + = LabelProperty {name = newValue, ..} +instance Property "Value" LabelProperty where + type PropertyType "Value" LabelProperty = Value Prelude.Text + set newValue LabelProperty {..} + = LabelProperty {value = newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/LabelProperty.hs-boot b/gen/Stratosphere/APS/Workspace/LabelProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LabelProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.LabelProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LabelProperty :: Prelude.Type +instance ToResourceProperties LabelProperty +instance Prelude.Eq LabelProperty +instance Prelude.Show LabelProperty +instance JSON.ToJSON LabelProperty diff --git a/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetEntryProperty.hs b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetEntryProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetEntryProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.APS.Workspace.LimitsPerLabelSetEntryProperty ( + LimitsPerLabelSetEntryProperty(..), + mkLimitsPerLabelSetEntryProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LimitsPerLabelSetEntryProperty + = -- | See: + LimitsPerLabelSetEntryProperty {haddock_workaround_ :: (), + -- | See: + maxSeries :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLimitsPerLabelSetEntryProperty :: LimitsPerLabelSetEntryProperty +mkLimitsPerLabelSetEntryProperty + = LimitsPerLabelSetEntryProperty + {haddock_workaround_ = (), maxSeries = Prelude.Nothing} +instance ToResourceProperties LimitsPerLabelSetEntryProperty where + toResourceProperties LimitsPerLabelSetEntryProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.LimitsPerLabelSetEntry", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "MaxSeries" Prelude.<$> maxSeries])} +instance JSON.ToJSON LimitsPerLabelSetEntryProperty where + toJSON LimitsPerLabelSetEntryProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "MaxSeries" Prelude.<$> maxSeries])) +instance Property "MaxSeries" LimitsPerLabelSetEntryProperty where + type PropertyType "MaxSeries" LimitsPerLabelSetEntryProperty = Value Prelude.Integer + set newValue LimitsPerLabelSetEntryProperty {..} + = LimitsPerLabelSetEntryProperty + {maxSeries = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetEntryProperty.hs-boot b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetEntryProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetEntryProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.LimitsPerLabelSetEntryProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LimitsPerLabelSetEntryProperty :: Prelude.Type +instance ToResourceProperties LimitsPerLabelSetEntryProperty +instance Prelude.Eq LimitsPerLabelSetEntryProperty +instance Prelude.Show LimitsPerLabelSetEntryProperty +instance JSON.ToJSON LimitsPerLabelSetEntryProperty diff --git a/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetProperty.hs b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetProperty.hs @@ -0,0 +1,43 @@ +module Stratosphere.APS.Workspace.LimitsPerLabelSetProperty ( + module Exports, LimitsPerLabelSetProperty(..), + mkLimitsPerLabelSetProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Workspace.LabelProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Workspace.LimitsPerLabelSetEntryProperty as Exports +import Stratosphere.ResourceProperties +data LimitsPerLabelSetProperty + = -- | See: + LimitsPerLabelSetProperty {haddock_workaround_ :: (), + -- | See: + labelSet :: [LabelProperty], + -- | See: + limits :: LimitsPerLabelSetEntryProperty} + deriving stock (Prelude.Eq, Prelude.Show) +mkLimitsPerLabelSetProperty :: + [LabelProperty] + -> LimitsPerLabelSetEntryProperty -> LimitsPerLabelSetProperty +mkLimitsPerLabelSetProperty labelSet limits + = LimitsPerLabelSetProperty + {haddock_workaround_ = (), labelSet = labelSet, limits = limits} +instance ToResourceProperties LimitsPerLabelSetProperty where + toResourceProperties LimitsPerLabelSetProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.LimitsPerLabelSet", + supportsTags = Prelude.False, + properties = ["LabelSet" JSON..= labelSet, + "Limits" JSON..= limits]} +instance JSON.ToJSON LimitsPerLabelSetProperty where + toJSON LimitsPerLabelSetProperty {..} + = JSON.object + ["LabelSet" JSON..= labelSet, "Limits" JSON..= limits] +instance Property "LabelSet" LimitsPerLabelSetProperty where + type PropertyType "LabelSet" LimitsPerLabelSetProperty = [LabelProperty] + set newValue LimitsPerLabelSetProperty {..} + = LimitsPerLabelSetProperty {labelSet = newValue, ..} +instance Property "Limits" LimitsPerLabelSetProperty where + type PropertyType "Limits" LimitsPerLabelSetProperty = LimitsPerLabelSetEntryProperty + set newValue LimitsPerLabelSetProperty {..} + = LimitsPerLabelSetProperty {limits = newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetProperty.hs-boot b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LimitsPerLabelSetProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.LimitsPerLabelSetProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LimitsPerLabelSetProperty :: Prelude.Type +instance ToResourceProperties LimitsPerLabelSetProperty +instance Prelude.Eq LimitsPerLabelSetProperty +instance Prelude.Show LimitsPerLabelSetProperty +instance JSON.ToJSON LimitsPerLabelSetProperty diff --git a/gen/Stratosphere/APS/Workspace/LoggingConfigurationProperty.hs b/gen/Stratosphere/APS/Workspace/LoggingConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LoggingConfigurationProperty.hs @@ -0,0 +1,37 @@ +module Stratosphere.APS.Workspace.LoggingConfigurationProperty ( + LoggingConfigurationProperty(..), mkLoggingConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LoggingConfigurationProperty + = -- | See: + LoggingConfigurationProperty {haddock_workaround_ :: (), + -- | See: + logGroupArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingConfigurationProperty :: LoggingConfigurationProperty +mkLoggingConfigurationProperty + = LoggingConfigurationProperty + {haddock_workaround_ = (), logGroupArn = Prelude.Nothing} +instance ToResourceProperties LoggingConfigurationProperty where + toResourceProperties LoggingConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.LoggingConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupArn" Prelude.<$> logGroupArn])} +instance JSON.ToJSON LoggingConfigurationProperty where + toJSON LoggingConfigurationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LogGroupArn" Prelude.<$> logGroupArn])) +instance Property "LogGroupArn" LoggingConfigurationProperty where + type PropertyType "LogGroupArn" LoggingConfigurationProperty = Value Prelude.Text + set newValue LoggingConfigurationProperty {..} + = LoggingConfigurationProperty + {logGroupArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/LoggingConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Workspace/LoggingConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LoggingConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.LoggingConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingConfigurationProperty :: Prelude.Type +instance ToResourceProperties LoggingConfigurationProperty +instance Prelude.Eq LoggingConfigurationProperty +instance Prelude.Show LoggingConfigurationProperty +instance JSON.ToJSON LoggingConfigurationProperty diff --git a/gen/Stratosphere/APS/Workspace/LoggingDestinationProperty.hs b/gen/Stratosphere/APS/Workspace/LoggingDestinationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LoggingDestinationProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.APS.Workspace.LoggingDestinationProperty ( + module Exports, LoggingDestinationProperty(..), + mkLoggingDestinationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Workspace.CloudWatchLogDestinationProperty as Exports +import {-# SOURCE #-} Stratosphere.APS.Workspace.LoggingFilterProperty as Exports +import Stratosphere.ResourceProperties +data LoggingDestinationProperty + = -- | See: + LoggingDestinationProperty {haddock_workaround_ :: (), + -- | See: + cloudWatchLogs :: CloudWatchLogDestinationProperty, + -- | See: + filters :: LoggingFilterProperty} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingDestinationProperty :: + CloudWatchLogDestinationProperty + -> LoggingFilterProperty -> LoggingDestinationProperty +mkLoggingDestinationProperty cloudWatchLogs filters + = LoggingDestinationProperty + {haddock_workaround_ = (), cloudWatchLogs = cloudWatchLogs, + filters = filters} +instance ToResourceProperties LoggingDestinationProperty where + toResourceProperties LoggingDestinationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.LoggingDestination", + supportsTags = Prelude.False, + properties = ["CloudWatchLogs" JSON..= cloudWatchLogs, + "Filters" JSON..= filters]} +instance JSON.ToJSON LoggingDestinationProperty where + toJSON LoggingDestinationProperty {..} + = JSON.object + ["CloudWatchLogs" JSON..= cloudWatchLogs, + "Filters" JSON..= filters] +instance Property "CloudWatchLogs" LoggingDestinationProperty where + type PropertyType "CloudWatchLogs" LoggingDestinationProperty = CloudWatchLogDestinationProperty + set newValue LoggingDestinationProperty {..} + = LoggingDestinationProperty {cloudWatchLogs = newValue, ..} +instance Property "Filters" LoggingDestinationProperty where + type PropertyType "Filters" LoggingDestinationProperty = LoggingFilterProperty + set newValue LoggingDestinationProperty {..} + = LoggingDestinationProperty {filters = newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/LoggingDestinationProperty.hs-boot b/gen/Stratosphere/APS/Workspace/LoggingDestinationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LoggingDestinationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.LoggingDestinationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingDestinationProperty :: Prelude.Type +instance ToResourceProperties LoggingDestinationProperty +instance Prelude.Eq LoggingDestinationProperty +instance Prelude.Show LoggingDestinationProperty +instance JSON.ToJSON LoggingDestinationProperty diff --git a/gen/Stratosphere/APS/Workspace/LoggingFilterProperty.hs b/gen/Stratosphere/APS/Workspace/LoggingFilterProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LoggingFilterProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.APS.Workspace.LoggingFilterProperty ( + LoggingFilterProperty(..), mkLoggingFilterProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LoggingFilterProperty + = -- | See: + LoggingFilterProperty {haddock_workaround_ :: (), + -- | See: + qspThreshold :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingFilterProperty :: + Value Prelude.Integer -> LoggingFilterProperty +mkLoggingFilterProperty qspThreshold + = LoggingFilterProperty + {haddock_workaround_ = (), qspThreshold = qspThreshold} +instance ToResourceProperties LoggingFilterProperty where + toResourceProperties LoggingFilterProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.LoggingFilter", + supportsTags = Prelude.False, + properties = ["QspThreshold" JSON..= qspThreshold]} +instance JSON.ToJSON LoggingFilterProperty where + toJSON LoggingFilterProperty {..} + = JSON.object ["QspThreshold" JSON..= qspThreshold] +instance Property "QspThreshold" LoggingFilterProperty where + type PropertyType "QspThreshold" LoggingFilterProperty = Value Prelude.Integer + set newValue LoggingFilterProperty {..} + = LoggingFilterProperty {qspThreshold = newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/LoggingFilterProperty.hs-boot b/gen/Stratosphere/APS/Workspace/LoggingFilterProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/LoggingFilterProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.LoggingFilterProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingFilterProperty :: Prelude.Type +instance ToResourceProperties LoggingFilterProperty +instance Prelude.Eq LoggingFilterProperty +instance Prelude.Show LoggingFilterProperty +instance JSON.ToJSON LoggingFilterProperty diff --git a/gen/Stratosphere/APS/Workspace/QueryLoggingConfigurationProperty.hs b/gen/Stratosphere/APS/Workspace/QueryLoggingConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/QueryLoggingConfigurationProperty.hs @@ -0,0 +1,33 @@ +module Stratosphere.APS.Workspace.QueryLoggingConfigurationProperty ( + module Exports, QueryLoggingConfigurationProperty(..), + mkQueryLoggingConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Workspace.LoggingDestinationProperty as Exports +import Stratosphere.ResourceProperties +data QueryLoggingConfigurationProperty + = -- | See: + QueryLoggingConfigurationProperty {haddock_workaround_ :: (), + -- | See: + destinations :: [LoggingDestinationProperty]} + deriving stock (Prelude.Eq, Prelude.Show) +mkQueryLoggingConfigurationProperty :: + [LoggingDestinationProperty] -> QueryLoggingConfigurationProperty +mkQueryLoggingConfigurationProperty destinations + = QueryLoggingConfigurationProperty + {haddock_workaround_ = (), destinations = destinations} +instance ToResourceProperties QueryLoggingConfigurationProperty where + toResourceProperties QueryLoggingConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.QueryLoggingConfiguration", + supportsTags = Prelude.False, + properties = ["Destinations" JSON..= destinations]} +instance JSON.ToJSON QueryLoggingConfigurationProperty where + toJSON QueryLoggingConfigurationProperty {..} + = JSON.object ["Destinations" JSON..= destinations] +instance Property "Destinations" QueryLoggingConfigurationProperty where + type PropertyType "Destinations" QueryLoggingConfigurationProperty = [LoggingDestinationProperty] + set newValue QueryLoggingConfigurationProperty {..} + = QueryLoggingConfigurationProperty {destinations = newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/QueryLoggingConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Workspace/QueryLoggingConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/QueryLoggingConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.QueryLoggingConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data QueryLoggingConfigurationProperty :: Prelude.Type +instance ToResourceProperties QueryLoggingConfigurationProperty +instance Prelude.Eq QueryLoggingConfigurationProperty +instance Prelude.Show QueryLoggingConfigurationProperty +instance JSON.ToJSON QueryLoggingConfigurationProperty diff --git a/gen/Stratosphere/APS/Workspace/WorkspaceConfigurationProperty.hs b/gen/Stratosphere/APS/Workspace/WorkspaceConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/WorkspaceConfigurationProperty.hs @@ -0,0 +1,51 @@ +module Stratosphere.APS.Workspace.WorkspaceConfigurationProperty ( + module Exports, WorkspaceConfigurationProperty(..), + mkWorkspaceConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.APS.Workspace.LimitsPerLabelSetProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data WorkspaceConfigurationProperty + = -- | See: + WorkspaceConfigurationProperty {haddock_workaround_ :: (), + -- | See: + limitsPerLabelSets :: (Prelude.Maybe [LimitsPerLabelSetProperty]), + -- | See: + retentionPeriodInDays :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkWorkspaceConfigurationProperty :: WorkspaceConfigurationProperty +mkWorkspaceConfigurationProperty + = WorkspaceConfigurationProperty + {haddock_workaround_ = (), limitsPerLabelSets = Prelude.Nothing, + retentionPeriodInDays = Prelude.Nothing} +instance ToResourceProperties WorkspaceConfigurationProperty where + toResourceProperties WorkspaceConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::APS::Workspace.WorkspaceConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LimitsPerLabelSets" Prelude.<$> limitsPerLabelSets, + (JSON..=) "RetentionPeriodInDays" + Prelude.<$> retentionPeriodInDays])} +instance JSON.ToJSON WorkspaceConfigurationProperty where + toJSON WorkspaceConfigurationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "LimitsPerLabelSets" Prelude.<$> limitsPerLabelSets, + (JSON..=) "RetentionPeriodInDays" + Prelude.<$> retentionPeriodInDays])) +instance Property "LimitsPerLabelSets" WorkspaceConfigurationProperty where + type PropertyType "LimitsPerLabelSets" WorkspaceConfigurationProperty = [LimitsPerLabelSetProperty] + set newValue WorkspaceConfigurationProperty {..} + = WorkspaceConfigurationProperty + {limitsPerLabelSets = Prelude.pure newValue, ..} +instance Property "RetentionPeriodInDays" WorkspaceConfigurationProperty where + type PropertyType "RetentionPeriodInDays" WorkspaceConfigurationProperty = Value Prelude.Integer + set newValue WorkspaceConfigurationProperty {..} + = WorkspaceConfigurationProperty + {retentionPeriodInDays = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/APS/Workspace/WorkspaceConfigurationProperty.hs-boot b/gen/Stratosphere/APS/Workspace/WorkspaceConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/APS/Workspace/WorkspaceConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.APS.Workspace.WorkspaceConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data WorkspaceConfigurationProperty :: Prelude.Type +instance ToResourceProperties WorkspaceConfigurationProperty +instance Prelude.Eq WorkspaceConfigurationProperty +instance Prelude.Show WorkspaceConfigurationProperty +instance JSON.ToJSON WorkspaceConfigurationProperty diff --git a/stratosphere-aps.cabal b/stratosphere-aps.cabal new file mode 100644 --- /dev/null +++ b/stratosphere-aps.cabal @@ -0,0 +1,102 @@ +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-aps +version: 1.0.0 +synopsis: Stratosphere integration for AWS APS. +description: Integration into stratosphere to generate resources and properties for AWS APS +category: AWS, Cloud, APS +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.APS.AnomalyDetector + Stratosphere.APS.AnomalyDetector.AnomalyDetectorConfigurationProperty + Stratosphere.APS.AnomalyDetector.IgnoreNearExpectedProperty + Stratosphere.APS.AnomalyDetector.LabelProperty + Stratosphere.APS.AnomalyDetector.MissingDataActionProperty + Stratosphere.APS.AnomalyDetector.RandomCutForestConfigurationProperty + Stratosphere.APS.ResourcePolicy + Stratosphere.APS.RuleGroupsNamespace + Stratosphere.APS.Scraper + Stratosphere.APS.Scraper.AmpConfigurationProperty + Stratosphere.APS.Scraper.CloudWatchLogDestinationProperty + Stratosphere.APS.Scraper.ComponentConfigProperty + Stratosphere.APS.Scraper.DestinationProperty + Stratosphere.APS.Scraper.EksConfigurationProperty + Stratosphere.APS.Scraper.RoleConfigurationProperty + Stratosphere.APS.Scraper.ScrapeConfigurationProperty + Stratosphere.APS.Scraper.ScraperComponentProperty + Stratosphere.APS.Scraper.ScraperLoggingConfigurationProperty + Stratosphere.APS.Scraper.ScraperLoggingDestinationProperty + Stratosphere.APS.Scraper.SourceProperty + Stratosphere.APS.Workspace + Stratosphere.APS.Workspace.CloudWatchLogDestinationProperty + Stratosphere.APS.Workspace.LabelProperty + Stratosphere.APS.Workspace.LimitsPerLabelSetEntryProperty + Stratosphere.APS.Workspace.LimitsPerLabelSetProperty + Stratosphere.APS.Workspace.LoggingConfigurationProperty + Stratosphere.APS.Workspace.LoggingDestinationProperty + Stratosphere.APS.Workspace.LoggingFilterProperty + Stratosphere.APS.Workspace.QueryLoggingConfigurationProperty + Stratosphere.APS.Workspace.WorkspaceConfigurationProperty + other-modules: + Paths_stratosphere_aps + 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