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/EKS/AccessEntry.hs b/gen/Stratosphere/EKS/AccessEntry.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/AccessEntry.hs @@ -0,0 +1,91 @@ +module Stratosphere.EKS.AccessEntry ( + module Exports, AccessEntry(..), mkAccessEntry + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.AccessEntry.AccessPolicyProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data AccessEntry + = -- | See: + AccessEntry {haddock_workaround_ :: (), + -- | See: + accessPolicies :: (Prelude.Maybe [AccessPolicyProperty]), + -- | See: + clusterName :: (Value Prelude.Text), + -- | See: + kubernetesGroups :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + principalArn :: (Value Prelude.Text), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + type' :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + username :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessEntry :: + Value Prelude.Text -> Value Prelude.Text -> AccessEntry +mkAccessEntry clusterName principalArn + = AccessEntry + {haddock_workaround_ = (), clusterName = clusterName, + principalArn = principalArn, accessPolicies = Prelude.Nothing, + kubernetesGroups = Prelude.Nothing, tags = Prelude.Nothing, + type' = Prelude.Nothing, username = Prelude.Nothing} +instance ToResourceProperties AccessEntry where + toResourceProperties AccessEntry {..} + = ResourceProperties + {awsType = "AWS::EKS::AccessEntry", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, + "PrincipalArn" JSON..= principalArn] + (Prelude.catMaybes + [(JSON..=) "AccessPolicies" Prelude.<$> accessPolicies, + (JSON..=) "KubernetesGroups" Prelude.<$> kubernetesGroups, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "Type" Prelude.<$> type', + (JSON..=) "Username" Prelude.<$> username]))} +instance JSON.ToJSON AccessEntry where + toJSON AccessEntry {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, + "PrincipalArn" JSON..= principalArn] + (Prelude.catMaybes + [(JSON..=) "AccessPolicies" Prelude.<$> accessPolicies, + (JSON..=) "KubernetesGroups" Prelude.<$> kubernetesGroups, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "Type" Prelude.<$> type', + (JSON..=) "Username" Prelude.<$> username]))) +instance Property "AccessPolicies" AccessEntry where + type PropertyType "AccessPolicies" AccessEntry = [AccessPolicyProperty] + set newValue AccessEntry {..} + = AccessEntry {accessPolicies = Prelude.pure newValue, ..} +instance Property "ClusterName" AccessEntry where + type PropertyType "ClusterName" AccessEntry = Value Prelude.Text + set newValue AccessEntry {..} + = AccessEntry {clusterName = newValue, ..} +instance Property "KubernetesGroups" AccessEntry where + type PropertyType "KubernetesGroups" AccessEntry = ValueList Prelude.Text + set newValue AccessEntry {..} + = AccessEntry {kubernetesGroups = Prelude.pure newValue, ..} +instance Property "PrincipalArn" AccessEntry where + type PropertyType "PrincipalArn" AccessEntry = Value Prelude.Text + set newValue AccessEntry {..} + = AccessEntry {principalArn = newValue, ..} +instance Property "Tags" AccessEntry where + type PropertyType "Tags" AccessEntry = [Tag] + set newValue AccessEntry {..} + = AccessEntry {tags = Prelude.pure newValue, ..} +instance Property "Type" AccessEntry where + type PropertyType "Type" AccessEntry = Value Prelude.Text + set newValue AccessEntry {..} + = AccessEntry {type' = Prelude.pure newValue, ..} +instance Property "Username" AccessEntry where + type PropertyType "Username" AccessEntry = Value Prelude.Text + set newValue AccessEntry {..} + = AccessEntry {username = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/AccessEntry/AccessPolicyProperty.hs b/gen/Stratosphere/EKS/AccessEntry/AccessPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/AccessEntry/AccessPolicyProperty.hs @@ -0,0 +1,42 @@ +module Stratosphere.EKS.AccessEntry.AccessPolicyProperty ( + module Exports, AccessPolicyProperty(..), mkAccessPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.AccessEntry.AccessScopeProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AccessPolicyProperty + = -- | See: + AccessPolicyProperty {haddock_workaround_ :: (), + -- | See: + accessScope :: AccessScopeProperty, + -- | See: + policyArn :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessPolicyProperty :: + AccessScopeProperty -> Value Prelude.Text -> AccessPolicyProperty +mkAccessPolicyProperty accessScope policyArn + = AccessPolicyProperty + {haddock_workaround_ = (), accessScope = accessScope, + policyArn = policyArn} +instance ToResourceProperties AccessPolicyProperty where + toResourceProperties AccessPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::AccessEntry.AccessPolicy", + supportsTags = Prelude.False, + properties = ["AccessScope" JSON..= accessScope, + "PolicyArn" JSON..= policyArn]} +instance JSON.ToJSON AccessPolicyProperty where + toJSON AccessPolicyProperty {..} + = JSON.object + ["AccessScope" JSON..= accessScope, "PolicyArn" JSON..= policyArn] +instance Property "AccessScope" AccessPolicyProperty where + type PropertyType "AccessScope" AccessPolicyProperty = AccessScopeProperty + set newValue AccessPolicyProperty {..} + = AccessPolicyProperty {accessScope = newValue, ..} +instance Property "PolicyArn" AccessPolicyProperty where + type PropertyType "PolicyArn" AccessPolicyProperty = Value Prelude.Text + set newValue AccessPolicyProperty {..} + = AccessPolicyProperty {policyArn = newValue, ..} diff --git a/gen/Stratosphere/EKS/AccessEntry/AccessPolicyProperty.hs-boot b/gen/Stratosphere/EKS/AccessEntry/AccessPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/AccessEntry/AccessPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.AccessEntry.AccessPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AccessPolicyProperty :: Prelude.Type +instance ToResourceProperties AccessPolicyProperty +instance Prelude.Eq AccessPolicyProperty +instance Prelude.Show AccessPolicyProperty +instance JSON.ToJSON AccessPolicyProperty diff --git a/gen/Stratosphere/EKS/AccessEntry/AccessScopeProperty.hs b/gen/Stratosphere/EKS/AccessEntry/AccessScopeProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/AccessEntry/AccessScopeProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.EKS.AccessEntry.AccessScopeProperty ( + AccessScopeProperty(..), mkAccessScopeProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AccessScopeProperty + = -- | See: + AccessScopeProperty {haddock_workaround_ :: (), + -- | See: + namespaces :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + type' :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessScopeProperty :: Value Prelude.Text -> AccessScopeProperty +mkAccessScopeProperty type' + = AccessScopeProperty + {haddock_workaround_ = (), type' = type', + namespaces = Prelude.Nothing} +instance ToResourceProperties AccessScopeProperty where + toResourceProperties AccessScopeProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::AccessEntry.AccessScope", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "Namespaces" Prelude.<$> namespaces]))} +instance JSON.ToJSON AccessScopeProperty where + toJSON AccessScopeProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "Namespaces" Prelude.<$> namespaces]))) +instance Property "Namespaces" AccessScopeProperty where + type PropertyType "Namespaces" AccessScopeProperty = ValueList Prelude.Text + set newValue AccessScopeProperty {..} + = AccessScopeProperty {namespaces = Prelude.pure newValue, ..} +instance Property "Type" AccessScopeProperty where + type PropertyType "Type" AccessScopeProperty = Value Prelude.Text + set newValue AccessScopeProperty {..} + = AccessScopeProperty {type' = newValue, ..} diff --git a/gen/Stratosphere/EKS/AccessEntry/AccessScopeProperty.hs-boot b/gen/Stratosphere/EKS/AccessEntry/AccessScopeProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/AccessEntry/AccessScopeProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.AccessEntry.AccessScopeProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AccessScopeProperty :: Prelude.Type +instance ToResourceProperties AccessScopeProperty +instance Prelude.Eq AccessScopeProperty +instance Prelude.Show AccessScopeProperty +instance JSON.ToJSON AccessScopeProperty diff --git a/gen/Stratosphere/EKS/Addon.hs b/gen/Stratosphere/EKS/Addon.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Addon.hs @@ -0,0 +1,118 @@ +module Stratosphere.EKS.Addon ( + module Exports, Addon(..), mkAddon + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Addon.NamespaceConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Addon.PodIdentityAssociationProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data Addon + = -- | See: + Addon {haddock_workaround_ :: (), + -- | See: + addonName :: (Value Prelude.Text), + -- | See: + addonVersion :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + clusterName :: (Value Prelude.Text), + -- | See: + configurationValues :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + namespaceConfig :: (Prelude.Maybe NamespaceConfigProperty), + -- | See: + podIdentityAssociations :: (Prelude.Maybe [PodIdentityAssociationProperty]), + -- | See: + preserveOnDelete :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + resolveConflicts :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + serviceAccountRoleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe [Tag])} + deriving stock (Prelude.Eq, Prelude.Show) +mkAddon :: Value Prelude.Text -> Value Prelude.Text -> Addon +mkAddon addonName clusterName + = Addon + {haddock_workaround_ = (), addonName = addonName, + clusterName = clusterName, addonVersion = Prelude.Nothing, + configurationValues = Prelude.Nothing, + namespaceConfig = Prelude.Nothing, + podIdentityAssociations = Prelude.Nothing, + preserveOnDelete = Prelude.Nothing, + resolveConflicts = Prelude.Nothing, + serviceAccountRoleArn = Prelude.Nothing, tags = Prelude.Nothing} +instance ToResourceProperties Addon where + toResourceProperties Addon {..} + = ResourceProperties + {awsType = "AWS::EKS::Addon", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["AddonName" JSON..= addonName, "ClusterName" JSON..= clusterName] + (Prelude.catMaybes + [(JSON..=) "AddonVersion" Prelude.<$> addonVersion, + (JSON..=) "ConfigurationValues" Prelude.<$> configurationValues, + (JSON..=) "NamespaceConfig" Prelude.<$> namespaceConfig, + (JSON..=) "PodIdentityAssociations" + Prelude.<$> podIdentityAssociations, + (JSON..=) "PreserveOnDelete" Prelude.<$> preserveOnDelete, + (JSON..=) "ResolveConflicts" Prelude.<$> resolveConflicts, + (JSON..=) "ServiceAccountRoleArn" + Prelude.<$> serviceAccountRoleArn, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON Addon where + toJSON Addon {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["AddonName" JSON..= addonName, "ClusterName" JSON..= clusterName] + (Prelude.catMaybes + [(JSON..=) "AddonVersion" Prelude.<$> addonVersion, + (JSON..=) "ConfigurationValues" Prelude.<$> configurationValues, + (JSON..=) "NamespaceConfig" Prelude.<$> namespaceConfig, + (JSON..=) "PodIdentityAssociations" + Prelude.<$> podIdentityAssociations, + (JSON..=) "PreserveOnDelete" Prelude.<$> preserveOnDelete, + (JSON..=) "ResolveConflicts" Prelude.<$> resolveConflicts, + (JSON..=) "ServiceAccountRoleArn" + Prelude.<$> serviceAccountRoleArn, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "AddonName" Addon where + type PropertyType "AddonName" Addon = Value Prelude.Text + set newValue Addon {..} = Addon {addonName = newValue, ..} +instance Property "AddonVersion" Addon where + type PropertyType "AddonVersion" Addon = Value Prelude.Text + set newValue Addon {..} + = Addon {addonVersion = Prelude.pure newValue, ..} +instance Property "ClusterName" Addon where + type PropertyType "ClusterName" Addon = Value Prelude.Text + set newValue Addon {..} = Addon {clusterName = newValue, ..} +instance Property "ConfigurationValues" Addon where + type PropertyType "ConfigurationValues" Addon = Value Prelude.Text + set newValue Addon {..} + = Addon {configurationValues = Prelude.pure newValue, ..} +instance Property "NamespaceConfig" Addon where + type PropertyType "NamespaceConfig" Addon = NamespaceConfigProperty + set newValue Addon {..} + = Addon {namespaceConfig = Prelude.pure newValue, ..} +instance Property "PodIdentityAssociations" Addon where + type PropertyType "PodIdentityAssociations" Addon = [PodIdentityAssociationProperty] + set newValue Addon {..} + = Addon {podIdentityAssociations = Prelude.pure newValue, ..} +instance Property "PreserveOnDelete" Addon where + type PropertyType "PreserveOnDelete" Addon = Value Prelude.Bool + set newValue Addon {..} + = Addon {preserveOnDelete = Prelude.pure newValue, ..} +instance Property "ResolveConflicts" Addon where + type PropertyType "ResolveConflicts" Addon = Value Prelude.Text + set newValue Addon {..} + = Addon {resolveConflicts = Prelude.pure newValue, ..} +instance Property "ServiceAccountRoleArn" Addon where + type PropertyType "ServiceAccountRoleArn" Addon = Value Prelude.Text + set newValue Addon {..} + = Addon {serviceAccountRoleArn = Prelude.pure newValue, ..} +instance Property "Tags" Addon where + type PropertyType "Tags" Addon = [Tag] + set newValue Addon {..} = Addon {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Addon/NamespaceConfigProperty.hs b/gen/Stratosphere/EKS/Addon/NamespaceConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Addon/NamespaceConfigProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.EKS.Addon.NamespaceConfigProperty ( + NamespaceConfigProperty(..), mkNamespaceConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data NamespaceConfigProperty + = -- | See: + NamespaceConfigProperty {haddock_workaround_ :: (), + -- | See: + namespace :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkNamespaceConfigProperty :: + Value Prelude.Text -> NamespaceConfigProperty +mkNamespaceConfigProperty namespace + = NamespaceConfigProperty + {haddock_workaround_ = (), namespace = namespace} +instance ToResourceProperties NamespaceConfigProperty where + toResourceProperties NamespaceConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Addon.NamespaceConfig", + supportsTags = Prelude.False, + properties = ["Namespace" JSON..= namespace]} +instance JSON.ToJSON NamespaceConfigProperty where + toJSON NamespaceConfigProperty {..} + = JSON.object ["Namespace" JSON..= namespace] +instance Property "Namespace" NamespaceConfigProperty where + type PropertyType "Namespace" NamespaceConfigProperty = Value Prelude.Text + set newValue NamespaceConfigProperty {..} + = NamespaceConfigProperty {namespace = newValue, ..} diff --git a/gen/Stratosphere/EKS/Addon/NamespaceConfigProperty.hs-boot b/gen/Stratosphere/EKS/Addon/NamespaceConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Addon/NamespaceConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Addon.NamespaceConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data NamespaceConfigProperty :: Prelude.Type +instance ToResourceProperties NamespaceConfigProperty +instance Prelude.Eq NamespaceConfigProperty +instance Prelude.Show NamespaceConfigProperty +instance JSON.ToJSON NamespaceConfigProperty diff --git a/gen/Stratosphere/EKS/Addon/PodIdentityAssociationProperty.hs b/gen/Stratosphere/EKS/Addon/PodIdentityAssociationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Addon/PodIdentityAssociationProperty.hs @@ -0,0 +1,44 @@ +module Stratosphere.EKS.Addon.PodIdentityAssociationProperty ( + PodIdentityAssociationProperty(..), + mkPodIdentityAssociationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data PodIdentityAssociationProperty + = -- | See: + PodIdentityAssociationProperty {haddock_workaround_ :: (), + -- | See: + roleArn :: (Value Prelude.Text), + -- | See: + serviceAccount :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkPodIdentityAssociationProperty :: + Value Prelude.Text + -> Value Prelude.Text -> PodIdentityAssociationProperty +mkPodIdentityAssociationProperty roleArn serviceAccount + = PodIdentityAssociationProperty + {haddock_workaround_ = (), roleArn = roleArn, + serviceAccount = serviceAccount} +instance ToResourceProperties PodIdentityAssociationProperty where + toResourceProperties PodIdentityAssociationProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Addon.PodIdentityAssociation", + supportsTags = Prelude.False, + properties = ["RoleArn" JSON..= roleArn, + "ServiceAccount" JSON..= serviceAccount]} +instance JSON.ToJSON PodIdentityAssociationProperty where + toJSON PodIdentityAssociationProperty {..} + = JSON.object + ["RoleArn" JSON..= roleArn, + "ServiceAccount" JSON..= serviceAccount] +instance Property "RoleArn" PodIdentityAssociationProperty where + type PropertyType "RoleArn" PodIdentityAssociationProperty = Value Prelude.Text + set newValue PodIdentityAssociationProperty {..} + = PodIdentityAssociationProperty {roleArn = newValue, ..} +instance Property "ServiceAccount" PodIdentityAssociationProperty where + type PropertyType "ServiceAccount" PodIdentityAssociationProperty = Value Prelude.Text + set newValue PodIdentityAssociationProperty {..} + = PodIdentityAssociationProperty {serviceAccount = newValue, ..} diff --git a/gen/Stratosphere/EKS/Addon/PodIdentityAssociationProperty.hs-boot b/gen/Stratosphere/EKS/Addon/PodIdentityAssociationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Addon/PodIdentityAssociationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Addon.PodIdentityAssociationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data PodIdentityAssociationProperty :: Prelude.Type +instance ToResourceProperties PodIdentityAssociationProperty +instance Prelude.Eq PodIdentityAssociationProperty +instance Prelude.Show PodIdentityAssociationProperty +instance JSON.ToJSON PodIdentityAssociationProperty diff --git a/gen/Stratosphere/EKS/Cluster.hs b/gen/Stratosphere/EKS/Cluster.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster.hs @@ -0,0 +1,201 @@ +module Stratosphere.EKS.Cluster ( + module Exports, Cluster(..), mkCluster + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.AccessConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ComputeConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.EncryptionConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.KubernetesNetworkConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.LoggingProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.OutpostConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.RemoteNetworkConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ResourcesVpcConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.StorageConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.UpgradePolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ZonalShiftConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data Cluster + = -- | See: + Cluster {haddock_workaround_ :: (), + -- | See: + accessConfig :: (Prelude.Maybe AccessConfigProperty), + -- | See: + bootstrapSelfManagedAddons :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + computeConfig :: (Prelude.Maybe ComputeConfigProperty), + -- | See: + deletionProtection :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + encryptionConfig :: (Prelude.Maybe [EncryptionConfigProperty]), + -- | See: + force :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + kubernetesNetworkConfig :: (Prelude.Maybe KubernetesNetworkConfigProperty), + -- | See: + logging :: (Prelude.Maybe LoggingProperty), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + outpostConfig :: (Prelude.Maybe OutpostConfigProperty), + -- | See: + remoteNetworkConfig :: (Prelude.Maybe RemoteNetworkConfigProperty), + -- | See: + resourcesVpcConfig :: ResourcesVpcConfigProperty, + -- | See: + roleArn :: (Value Prelude.Text), + -- | See: + storageConfig :: (Prelude.Maybe StorageConfigProperty), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + upgradePolicy :: (Prelude.Maybe UpgradePolicyProperty), + -- | See: + version :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + zonalShiftConfig :: (Prelude.Maybe ZonalShiftConfigProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkCluster :: + ResourcesVpcConfigProperty -> Value Prelude.Text -> Cluster +mkCluster resourcesVpcConfig roleArn + = Cluster + {haddock_workaround_ = (), resourcesVpcConfig = resourcesVpcConfig, + roleArn = roleArn, accessConfig = Prelude.Nothing, + bootstrapSelfManagedAddons = Prelude.Nothing, + computeConfig = Prelude.Nothing, + deletionProtection = Prelude.Nothing, + encryptionConfig = Prelude.Nothing, force = Prelude.Nothing, + kubernetesNetworkConfig = Prelude.Nothing, + logging = Prelude.Nothing, name = Prelude.Nothing, + outpostConfig = Prelude.Nothing, + remoteNetworkConfig = Prelude.Nothing, + storageConfig = Prelude.Nothing, tags = Prelude.Nothing, + upgradePolicy = Prelude.Nothing, version = Prelude.Nothing, + zonalShiftConfig = Prelude.Nothing} +instance ToResourceProperties Cluster where + toResourceProperties Cluster {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ResourcesVpcConfig" JSON..= resourcesVpcConfig, + "RoleArn" JSON..= roleArn] + (Prelude.catMaybes + [(JSON..=) "AccessConfig" Prelude.<$> accessConfig, + (JSON..=) "BootstrapSelfManagedAddons" + Prelude.<$> bootstrapSelfManagedAddons, + (JSON..=) "ComputeConfig" Prelude.<$> computeConfig, + (JSON..=) "DeletionProtection" Prelude.<$> deletionProtection, + (JSON..=) "EncryptionConfig" Prelude.<$> encryptionConfig, + (JSON..=) "Force" Prelude.<$> force, + (JSON..=) "KubernetesNetworkConfig" + Prelude.<$> kubernetesNetworkConfig, + (JSON..=) "Logging" Prelude.<$> logging, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "OutpostConfig" Prelude.<$> outpostConfig, + (JSON..=) "RemoteNetworkConfig" Prelude.<$> remoteNetworkConfig, + (JSON..=) "StorageConfig" Prelude.<$> storageConfig, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "UpgradePolicy" Prelude.<$> upgradePolicy, + (JSON..=) "Version" Prelude.<$> version, + (JSON..=) "ZonalShiftConfig" Prelude.<$> zonalShiftConfig]))} +instance JSON.ToJSON Cluster where + toJSON Cluster {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ResourcesVpcConfig" JSON..= resourcesVpcConfig, + "RoleArn" JSON..= roleArn] + (Prelude.catMaybes + [(JSON..=) "AccessConfig" Prelude.<$> accessConfig, + (JSON..=) "BootstrapSelfManagedAddons" + Prelude.<$> bootstrapSelfManagedAddons, + (JSON..=) "ComputeConfig" Prelude.<$> computeConfig, + (JSON..=) "DeletionProtection" Prelude.<$> deletionProtection, + (JSON..=) "EncryptionConfig" Prelude.<$> encryptionConfig, + (JSON..=) "Force" Prelude.<$> force, + (JSON..=) "KubernetesNetworkConfig" + Prelude.<$> kubernetesNetworkConfig, + (JSON..=) "Logging" Prelude.<$> logging, + (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "OutpostConfig" Prelude.<$> outpostConfig, + (JSON..=) "RemoteNetworkConfig" Prelude.<$> remoteNetworkConfig, + (JSON..=) "StorageConfig" Prelude.<$> storageConfig, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "UpgradePolicy" Prelude.<$> upgradePolicy, + (JSON..=) "Version" Prelude.<$> version, + (JSON..=) "ZonalShiftConfig" Prelude.<$> zonalShiftConfig]))) +instance Property "AccessConfig" Cluster where + type PropertyType "AccessConfig" Cluster = AccessConfigProperty + set newValue Cluster {..} + = Cluster {accessConfig = Prelude.pure newValue, ..} +instance Property "BootstrapSelfManagedAddons" Cluster where + type PropertyType "BootstrapSelfManagedAddons" Cluster = Value Prelude.Bool + set newValue Cluster {..} + = Cluster {bootstrapSelfManagedAddons = Prelude.pure newValue, ..} +instance Property "ComputeConfig" Cluster where + type PropertyType "ComputeConfig" Cluster = ComputeConfigProperty + set newValue Cluster {..} + = Cluster {computeConfig = Prelude.pure newValue, ..} +instance Property "DeletionProtection" Cluster where + type PropertyType "DeletionProtection" Cluster = Value Prelude.Bool + set newValue Cluster {..} + = Cluster {deletionProtection = Prelude.pure newValue, ..} +instance Property "EncryptionConfig" Cluster where + type PropertyType "EncryptionConfig" Cluster = [EncryptionConfigProperty] + set newValue Cluster {..} + = Cluster {encryptionConfig = Prelude.pure newValue, ..} +instance Property "Force" Cluster where + type PropertyType "Force" Cluster = Value Prelude.Bool + set newValue Cluster {..} + = Cluster {force = Prelude.pure newValue, ..} +instance Property "KubernetesNetworkConfig" Cluster where + type PropertyType "KubernetesNetworkConfig" Cluster = KubernetesNetworkConfigProperty + set newValue Cluster {..} + = Cluster {kubernetesNetworkConfig = Prelude.pure newValue, ..} +instance Property "Logging" Cluster where + type PropertyType "Logging" Cluster = LoggingProperty + set newValue Cluster {..} + = Cluster {logging = Prelude.pure newValue, ..} +instance Property "Name" Cluster where + type PropertyType "Name" Cluster = Value Prelude.Text + set newValue Cluster {..} + = Cluster {name = Prelude.pure newValue, ..} +instance Property "OutpostConfig" Cluster where + type PropertyType "OutpostConfig" Cluster = OutpostConfigProperty + set newValue Cluster {..} + = Cluster {outpostConfig = Prelude.pure newValue, ..} +instance Property "RemoteNetworkConfig" Cluster where + type PropertyType "RemoteNetworkConfig" Cluster = RemoteNetworkConfigProperty + set newValue Cluster {..} + = Cluster {remoteNetworkConfig = Prelude.pure newValue, ..} +instance Property "ResourcesVpcConfig" Cluster where + type PropertyType "ResourcesVpcConfig" Cluster = ResourcesVpcConfigProperty + set newValue Cluster {..} + = Cluster {resourcesVpcConfig = newValue, ..} +instance Property "RoleArn" Cluster where + type PropertyType "RoleArn" Cluster = Value Prelude.Text + set newValue Cluster {..} = Cluster {roleArn = newValue, ..} +instance Property "StorageConfig" Cluster where + type PropertyType "StorageConfig" Cluster = StorageConfigProperty + set newValue Cluster {..} + = Cluster {storageConfig = Prelude.pure newValue, ..} +instance Property "Tags" Cluster where + type PropertyType "Tags" Cluster = [Tag] + set newValue Cluster {..} + = Cluster {tags = Prelude.pure newValue, ..} +instance Property "UpgradePolicy" Cluster where + type PropertyType "UpgradePolicy" Cluster = UpgradePolicyProperty + set newValue Cluster {..} + = Cluster {upgradePolicy = Prelude.pure newValue, ..} +instance Property "Version" Cluster where + type PropertyType "Version" Cluster = Value Prelude.Text + set newValue Cluster {..} + = Cluster {version = Prelude.pure newValue, ..} +instance Property "ZonalShiftConfig" Cluster where + type PropertyType "ZonalShiftConfig" Cluster = ZonalShiftConfigProperty + set newValue Cluster {..} + = Cluster {zonalShiftConfig = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/AccessConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/AccessConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/AccessConfigProperty.hs @@ -0,0 +1,50 @@ +module Stratosphere.EKS.Cluster.AccessConfigProperty ( + AccessConfigProperty(..), mkAccessConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AccessConfigProperty + = -- | See: + AccessConfigProperty {haddock_workaround_ :: (), + -- | See: + authenticationMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + bootstrapClusterCreatorAdminPermissions :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessConfigProperty :: AccessConfigProperty +mkAccessConfigProperty + = AccessConfigProperty + {haddock_workaround_ = (), authenticationMode = Prelude.Nothing, + bootstrapClusterCreatorAdminPermissions = Prelude.Nothing} +instance ToResourceProperties AccessConfigProperty where + toResourceProperties AccessConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.AccessConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AuthenticationMode" Prelude.<$> authenticationMode, + (JSON..=) "BootstrapClusterCreatorAdminPermissions" + Prelude.<$> bootstrapClusterCreatorAdminPermissions])} +instance JSON.ToJSON AccessConfigProperty where + toJSON AccessConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AuthenticationMode" Prelude.<$> authenticationMode, + (JSON..=) "BootstrapClusterCreatorAdminPermissions" + Prelude.<$> bootstrapClusterCreatorAdminPermissions])) +instance Property "AuthenticationMode" AccessConfigProperty where + type PropertyType "AuthenticationMode" AccessConfigProperty = Value Prelude.Text + set newValue AccessConfigProperty {..} + = AccessConfigProperty + {authenticationMode = Prelude.pure newValue, ..} +instance Property "BootstrapClusterCreatorAdminPermissions" AccessConfigProperty where + type PropertyType "BootstrapClusterCreatorAdminPermissions" AccessConfigProperty = Value Prelude.Bool + set newValue AccessConfigProperty {..} + = AccessConfigProperty + {bootstrapClusterCreatorAdminPermissions = Prelude.pure newValue, + ..} diff --git a/gen/Stratosphere/EKS/Cluster/AccessConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/AccessConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/AccessConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.AccessConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AccessConfigProperty :: Prelude.Type +instance ToResourceProperties AccessConfigProperty +instance Prelude.Eq AccessConfigProperty +instance Prelude.Show AccessConfigProperty +instance JSON.ToJSON AccessConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/BlockStorageProperty.hs b/gen/Stratosphere/EKS/Cluster/BlockStorageProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/BlockStorageProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.EKS.Cluster.BlockStorageProperty ( + BlockStorageProperty(..), mkBlockStorageProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data BlockStorageProperty + = -- | See: + BlockStorageProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkBlockStorageProperty :: BlockStorageProperty +mkBlockStorageProperty + = BlockStorageProperty + {haddock_workaround_ = (), enabled = Prelude.Nothing} +instance ToResourceProperties BlockStorageProperty where + toResourceProperties BlockStorageProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.BlockStorage", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])} +instance JSON.ToJSON BlockStorageProperty where + toJSON BlockStorageProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])) +instance Property "Enabled" BlockStorageProperty where + type PropertyType "Enabled" BlockStorageProperty = Value Prelude.Bool + set newValue BlockStorageProperty {..} + = BlockStorageProperty {enabled = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/BlockStorageProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/BlockStorageProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/BlockStorageProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.BlockStorageProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data BlockStorageProperty :: Prelude.Type +instance ToResourceProperties BlockStorageProperty +instance Prelude.Eq BlockStorageProperty +instance Prelude.Show BlockStorageProperty +instance JSON.ToJSON BlockStorageProperty diff --git a/gen/Stratosphere/EKS/Cluster/ClusterLoggingProperty.hs b/gen/Stratosphere/EKS/Cluster/ClusterLoggingProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ClusterLoggingProperty.hs @@ -0,0 +1,37 @@ +module Stratosphere.EKS.Cluster.ClusterLoggingProperty ( + module Exports, ClusterLoggingProperty(..), + mkClusterLoggingProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.LoggingTypeConfigProperty as Exports +import Stratosphere.ResourceProperties +data ClusterLoggingProperty + = -- | See: + ClusterLoggingProperty {haddock_workaround_ :: (), + -- | See: + enabledTypes :: (Prelude.Maybe [LoggingTypeConfigProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkClusterLoggingProperty :: ClusterLoggingProperty +mkClusterLoggingProperty + = ClusterLoggingProperty + {haddock_workaround_ = (), enabledTypes = Prelude.Nothing} +instance ToResourceProperties ClusterLoggingProperty where + toResourceProperties ClusterLoggingProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.ClusterLogging", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "EnabledTypes" Prelude.<$> enabledTypes])} +instance JSON.ToJSON ClusterLoggingProperty where + toJSON ClusterLoggingProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "EnabledTypes" Prelude.<$> enabledTypes])) +instance Property "EnabledTypes" ClusterLoggingProperty where + type PropertyType "EnabledTypes" ClusterLoggingProperty = [LoggingTypeConfigProperty] + set newValue ClusterLoggingProperty {..} + = ClusterLoggingProperty {enabledTypes = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ClusterLoggingProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ClusterLoggingProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ClusterLoggingProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ClusterLoggingProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ClusterLoggingProperty :: Prelude.Type +instance ToResourceProperties ClusterLoggingProperty +instance Prelude.Eq ClusterLoggingProperty +instance Prelude.Show ClusterLoggingProperty +instance JSON.ToJSON ClusterLoggingProperty diff --git a/gen/Stratosphere/EKS/Cluster/ComputeConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/ComputeConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ComputeConfigProperty.hs @@ -0,0 +1,53 @@ +module Stratosphere.EKS.Cluster.ComputeConfigProperty ( + ComputeConfigProperty(..), mkComputeConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ComputeConfigProperty + = -- | See: + ComputeConfigProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + nodePools :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + nodeRoleArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkComputeConfigProperty :: ComputeConfigProperty +mkComputeConfigProperty + = ComputeConfigProperty + {haddock_workaround_ = (), enabled = Prelude.Nothing, + nodePools = Prelude.Nothing, nodeRoleArn = Prelude.Nothing} +instance ToResourceProperties ComputeConfigProperty where + toResourceProperties ComputeConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.ComputeConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Enabled" Prelude.<$> enabled, + (JSON..=) "NodePools" Prelude.<$> nodePools, + (JSON..=) "NodeRoleArn" Prelude.<$> nodeRoleArn])} +instance JSON.ToJSON ComputeConfigProperty where + toJSON ComputeConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Enabled" Prelude.<$> enabled, + (JSON..=) "NodePools" Prelude.<$> nodePools, + (JSON..=) "NodeRoleArn" Prelude.<$> nodeRoleArn])) +instance Property "Enabled" ComputeConfigProperty where + type PropertyType "Enabled" ComputeConfigProperty = Value Prelude.Bool + set newValue ComputeConfigProperty {..} + = ComputeConfigProperty {enabled = Prelude.pure newValue, ..} +instance Property "NodePools" ComputeConfigProperty where + type PropertyType "NodePools" ComputeConfigProperty = ValueList Prelude.Text + set newValue ComputeConfigProperty {..} + = ComputeConfigProperty {nodePools = Prelude.pure newValue, ..} +instance Property "NodeRoleArn" ComputeConfigProperty where + type PropertyType "NodeRoleArn" ComputeConfigProperty = Value Prelude.Text + set newValue ComputeConfigProperty {..} + = ComputeConfigProperty {nodeRoleArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ComputeConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ComputeConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ComputeConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ComputeConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ComputeConfigProperty :: Prelude.Type +instance ToResourceProperties ComputeConfigProperty +instance Prelude.Eq ComputeConfigProperty +instance Prelude.Show ComputeConfigProperty +instance JSON.ToJSON ComputeConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/ControlPlanePlacementProperty.hs b/gen/Stratosphere/EKS/Cluster/ControlPlanePlacementProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ControlPlanePlacementProperty.hs @@ -0,0 +1,35 @@ +module Stratosphere.EKS.Cluster.ControlPlanePlacementProperty ( + ControlPlanePlacementProperty(..), mkControlPlanePlacementProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ControlPlanePlacementProperty + = -- | See: + ControlPlanePlacementProperty {haddock_workaround_ :: (), + -- | See: + groupName :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkControlPlanePlacementProperty :: ControlPlanePlacementProperty +mkControlPlanePlacementProperty + = ControlPlanePlacementProperty + {haddock_workaround_ = (), groupName = Prelude.Nothing} +instance ToResourceProperties ControlPlanePlacementProperty where + toResourceProperties ControlPlanePlacementProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.ControlPlanePlacement", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "GroupName" Prelude.<$> groupName])} +instance JSON.ToJSON ControlPlanePlacementProperty where + toJSON ControlPlanePlacementProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "GroupName" Prelude.<$> groupName])) +instance Property "GroupName" ControlPlanePlacementProperty where + type PropertyType "GroupName" ControlPlanePlacementProperty = Value Prelude.Text + set newValue ControlPlanePlacementProperty {..} + = ControlPlanePlacementProperty + {groupName = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ControlPlanePlacementProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ControlPlanePlacementProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ControlPlanePlacementProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ControlPlanePlacementProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ControlPlanePlacementProperty :: Prelude.Type +instance ToResourceProperties ControlPlanePlacementProperty +instance Prelude.Eq ControlPlanePlacementProperty +instance Prelude.Show ControlPlanePlacementProperty +instance JSON.ToJSON ControlPlanePlacementProperty diff --git a/gen/Stratosphere/EKS/Cluster/ElasticLoadBalancingProperty.hs b/gen/Stratosphere/EKS/Cluster/ElasticLoadBalancingProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ElasticLoadBalancingProperty.hs @@ -0,0 +1,35 @@ +module Stratosphere.EKS.Cluster.ElasticLoadBalancingProperty ( + ElasticLoadBalancingProperty(..), mkElasticLoadBalancingProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ElasticLoadBalancingProperty + = -- | See: + ElasticLoadBalancingProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkElasticLoadBalancingProperty :: ElasticLoadBalancingProperty +mkElasticLoadBalancingProperty + = ElasticLoadBalancingProperty + {haddock_workaround_ = (), enabled = Prelude.Nothing} +instance ToResourceProperties ElasticLoadBalancingProperty where + toResourceProperties ElasticLoadBalancingProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.ElasticLoadBalancing", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])} +instance JSON.ToJSON ElasticLoadBalancingProperty where + toJSON ElasticLoadBalancingProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])) +instance Property "Enabled" ElasticLoadBalancingProperty where + type PropertyType "Enabled" ElasticLoadBalancingProperty = Value Prelude.Bool + set newValue ElasticLoadBalancingProperty {..} + = ElasticLoadBalancingProperty + {enabled = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ElasticLoadBalancingProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ElasticLoadBalancingProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ElasticLoadBalancingProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ElasticLoadBalancingProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ElasticLoadBalancingProperty :: Prelude.Type +instance ToResourceProperties ElasticLoadBalancingProperty +instance Prelude.Eq ElasticLoadBalancingProperty +instance Prelude.Show ElasticLoadBalancingProperty +instance JSON.ToJSON ElasticLoadBalancingProperty diff --git a/gen/Stratosphere/EKS/Cluster/EncryptionConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/EncryptionConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/EncryptionConfigProperty.hs @@ -0,0 +1,47 @@ +module Stratosphere.EKS.Cluster.EncryptionConfigProperty ( + module Exports, EncryptionConfigProperty(..), + mkEncryptionConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ProviderProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data EncryptionConfigProperty + = -- | See: + EncryptionConfigProperty {haddock_workaround_ :: (), + -- | See: + provider :: (Prelude.Maybe ProviderProperty), + -- | See: + resources :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkEncryptionConfigProperty :: EncryptionConfigProperty +mkEncryptionConfigProperty + = EncryptionConfigProperty + {haddock_workaround_ = (), provider = Prelude.Nothing, + resources = Prelude.Nothing} +instance ToResourceProperties EncryptionConfigProperty where + toResourceProperties EncryptionConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.EncryptionConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Provider" Prelude.<$> provider, + (JSON..=) "Resources" Prelude.<$> resources])} +instance JSON.ToJSON EncryptionConfigProperty where + toJSON EncryptionConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Provider" Prelude.<$> provider, + (JSON..=) "Resources" Prelude.<$> resources])) +instance Property "Provider" EncryptionConfigProperty where + type PropertyType "Provider" EncryptionConfigProperty = ProviderProperty + set newValue EncryptionConfigProperty {..} + = EncryptionConfigProperty {provider = Prelude.pure newValue, ..} +instance Property "Resources" EncryptionConfigProperty where + type PropertyType "Resources" EncryptionConfigProperty = ValueList Prelude.Text + set newValue EncryptionConfigProperty {..} + = EncryptionConfigProperty {resources = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/EncryptionConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/EncryptionConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/EncryptionConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.EncryptionConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data EncryptionConfigProperty :: Prelude.Type +instance ToResourceProperties EncryptionConfigProperty +instance Prelude.Eq EncryptionConfigProperty +instance Prelude.Show EncryptionConfigProperty +instance JSON.ToJSON EncryptionConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/KubernetesNetworkConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/KubernetesNetworkConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/KubernetesNetworkConfigProperty.hs @@ -0,0 +1,69 @@ +module Stratosphere.EKS.Cluster.KubernetesNetworkConfigProperty ( + module Exports, KubernetesNetworkConfigProperty(..), + mkKubernetesNetworkConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ElasticLoadBalancingProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data KubernetesNetworkConfigProperty + = -- | See: + KubernetesNetworkConfigProperty {haddock_workaround_ :: (), + -- | See: + elasticLoadBalancing :: (Prelude.Maybe ElasticLoadBalancingProperty), + -- | See: + ipFamily :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + serviceIpv4Cidr :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + serviceIpv6Cidr :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkKubernetesNetworkConfigProperty :: + KubernetesNetworkConfigProperty +mkKubernetesNetworkConfigProperty + = KubernetesNetworkConfigProperty + {haddock_workaround_ = (), elasticLoadBalancing = Prelude.Nothing, + ipFamily = Prelude.Nothing, serviceIpv4Cidr = Prelude.Nothing, + serviceIpv6Cidr = Prelude.Nothing} +instance ToResourceProperties KubernetesNetworkConfigProperty where + toResourceProperties KubernetesNetworkConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.KubernetesNetworkConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ElasticLoadBalancing" Prelude.<$> elasticLoadBalancing, + (JSON..=) "IpFamily" Prelude.<$> ipFamily, + (JSON..=) "ServiceIpv4Cidr" Prelude.<$> serviceIpv4Cidr, + (JSON..=) "ServiceIpv6Cidr" Prelude.<$> serviceIpv6Cidr])} +instance JSON.ToJSON KubernetesNetworkConfigProperty where + toJSON KubernetesNetworkConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ElasticLoadBalancing" Prelude.<$> elasticLoadBalancing, + (JSON..=) "IpFamily" Prelude.<$> ipFamily, + (JSON..=) "ServiceIpv4Cidr" Prelude.<$> serviceIpv4Cidr, + (JSON..=) "ServiceIpv6Cidr" Prelude.<$> serviceIpv6Cidr])) +instance Property "ElasticLoadBalancing" KubernetesNetworkConfigProperty where + type PropertyType "ElasticLoadBalancing" KubernetesNetworkConfigProperty = ElasticLoadBalancingProperty + set newValue KubernetesNetworkConfigProperty {..} + = KubernetesNetworkConfigProperty + {elasticLoadBalancing = Prelude.pure newValue, ..} +instance Property "IpFamily" KubernetesNetworkConfigProperty where + type PropertyType "IpFamily" KubernetesNetworkConfigProperty = Value Prelude.Text + set newValue KubernetesNetworkConfigProperty {..} + = KubernetesNetworkConfigProperty + {ipFamily = Prelude.pure newValue, ..} +instance Property "ServiceIpv4Cidr" KubernetesNetworkConfigProperty where + type PropertyType "ServiceIpv4Cidr" KubernetesNetworkConfigProperty = Value Prelude.Text + set newValue KubernetesNetworkConfigProperty {..} + = KubernetesNetworkConfigProperty + {serviceIpv4Cidr = Prelude.pure newValue, ..} +instance Property "ServiceIpv6Cidr" KubernetesNetworkConfigProperty where + type PropertyType "ServiceIpv6Cidr" KubernetesNetworkConfigProperty = Value Prelude.Text + set newValue KubernetesNetworkConfigProperty {..} + = KubernetesNetworkConfigProperty + {serviceIpv6Cidr = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/KubernetesNetworkConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/KubernetesNetworkConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/KubernetesNetworkConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.KubernetesNetworkConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data KubernetesNetworkConfigProperty :: Prelude.Type +instance ToResourceProperties KubernetesNetworkConfigProperty +instance Prelude.Eq KubernetesNetworkConfigProperty +instance Prelude.Show KubernetesNetworkConfigProperty +instance JSON.ToJSON KubernetesNetworkConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/LoggingProperty.hs b/gen/Stratosphere/EKS/Cluster/LoggingProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/LoggingProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.EKS.Cluster.LoggingProperty ( + module Exports, LoggingProperty(..), mkLoggingProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ClusterLoggingProperty as Exports +import Stratosphere.ResourceProperties +data LoggingProperty + = -- | See: + LoggingProperty {haddock_workaround_ :: (), + -- | See: + clusterLogging :: (Prelude.Maybe ClusterLoggingProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingProperty :: LoggingProperty +mkLoggingProperty + = LoggingProperty + {haddock_workaround_ = (), clusterLogging = Prelude.Nothing} +instance ToResourceProperties LoggingProperty where + toResourceProperties LoggingProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.Logging", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ClusterLogging" Prelude.<$> clusterLogging])} +instance JSON.ToJSON LoggingProperty where + toJSON LoggingProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ClusterLogging" Prelude.<$> clusterLogging])) +instance Property "ClusterLogging" LoggingProperty where + type PropertyType "ClusterLogging" LoggingProperty = ClusterLoggingProperty + set newValue LoggingProperty {..} + = LoggingProperty {clusterLogging = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/LoggingProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/LoggingProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/LoggingProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.LoggingProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingProperty :: Prelude.Type +instance ToResourceProperties LoggingProperty +instance Prelude.Eq LoggingProperty +instance Prelude.Show LoggingProperty +instance JSON.ToJSON LoggingProperty diff --git a/gen/Stratosphere/EKS/Cluster/LoggingTypeConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/LoggingTypeConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/LoggingTypeConfigProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.EKS.Cluster.LoggingTypeConfigProperty ( + LoggingTypeConfigProperty(..), mkLoggingTypeConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LoggingTypeConfigProperty + = -- | See: + LoggingTypeConfigProperty {haddock_workaround_ :: (), + -- | See: + type' :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoggingTypeConfigProperty :: LoggingTypeConfigProperty +mkLoggingTypeConfigProperty + = LoggingTypeConfigProperty + {haddock_workaround_ = (), type' = Prelude.Nothing} +instance ToResourceProperties LoggingTypeConfigProperty where + toResourceProperties LoggingTypeConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.LoggingTypeConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Type" Prelude.<$> type'])} +instance JSON.ToJSON LoggingTypeConfigProperty where + toJSON LoggingTypeConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Type" Prelude.<$> type'])) +instance Property "Type" LoggingTypeConfigProperty where + type PropertyType "Type" LoggingTypeConfigProperty = Value Prelude.Text + set newValue LoggingTypeConfigProperty {..} + = LoggingTypeConfigProperty {type' = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/LoggingTypeConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/LoggingTypeConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/LoggingTypeConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.LoggingTypeConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LoggingTypeConfigProperty :: Prelude.Type +instance ToResourceProperties LoggingTypeConfigProperty +instance Prelude.Eq LoggingTypeConfigProperty +instance Prelude.Show LoggingTypeConfigProperty +instance JSON.ToJSON LoggingTypeConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/OutpostConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/OutpostConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/OutpostConfigProperty.hs @@ -0,0 +1,62 @@ +module Stratosphere.EKS.Cluster.OutpostConfigProperty ( + module Exports, OutpostConfigProperty(..), mkOutpostConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.ControlPlanePlacementProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data OutpostConfigProperty + = -- | See: + OutpostConfigProperty {haddock_workaround_ :: (), + -- | See: + controlPlaneInstanceType :: (Value Prelude.Text), + -- | See: + controlPlanePlacement :: (Prelude.Maybe ControlPlanePlacementProperty), + -- | See: + outpostArns :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkOutpostConfigProperty :: + Value Prelude.Text + -> ValueList Prelude.Text -> OutpostConfigProperty +mkOutpostConfigProperty controlPlaneInstanceType outpostArns + = OutpostConfigProperty + {haddock_workaround_ = (), + controlPlaneInstanceType = controlPlaneInstanceType, + outpostArns = outpostArns, controlPlanePlacement = Prelude.Nothing} +instance ToResourceProperties OutpostConfigProperty where + toResourceProperties OutpostConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.OutpostConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ControlPlaneInstanceType" JSON..= controlPlaneInstanceType, + "OutpostArns" JSON..= outpostArns] + (Prelude.catMaybes + [(JSON..=) "ControlPlanePlacement" + Prelude.<$> controlPlanePlacement]))} +instance JSON.ToJSON OutpostConfigProperty where + toJSON OutpostConfigProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ControlPlaneInstanceType" JSON..= controlPlaneInstanceType, + "OutpostArns" JSON..= outpostArns] + (Prelude.catMaybes + [(JSON..=) "ControlPlanePlacement" + Prelude.<$> controlPlanePlacement]))) +instance Property "ControlPlaneInstanceType" OutpostConfigProperty where + type PropertyType "ControlPlaneInstanceType" OutpostConfigProperty = Value Prelude.Text + set newValue OutpostConfigProperty {..} + = OutpostConfigProperty {controlPlaneInstanceType = newValue, ..} +instance Property "ControlPlanePlacement" OutpostConfigProperty where + type PropertyType "ControlPlanePlacement" OutpostConfigProperty = ControlPlanePlacementProperty + set newValue OutpostConfigProperty {..} + = OutpostConfigProperty + {controlPlanePlacement = Prelude.pure newValue, ..} +instance Property "OutpostArns" OutpostConfigProperty where + type PropertyType "OutpostArns" OutpostConfigProperty = ValueList Prelude.Text + set newValue OutpostConfigProperty {..} + = OutpostConfigProperty {outpostArns = newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/OutpostConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/OutpostConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/OutpostConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.OutpostConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data OutpostConfigProperty :: Prelude.Type +instance ToResourceProperties OutpostConfigProperty +instance Prelude.Eq OutpostConfigProperty +instance Prelude.Show OutpostConfigProperty +instance JSON.ToJSON OutpostConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/ProviderProperty.hs b/gen/Stratosphere/EKS/Cluster/ProviderProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ProviderProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.EKS.Cluster.ProviderProperty ( + ProviderProperty(..), mkProviderProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ProviderProperty + = -- | See: + ProviderProperty {haddock_workaround_ :: (), + -- | See: + keyArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkProviderProperty :: ProviderProperty +mkProviderProperty + = ProviderProperty + {haddock_workaround_ = (), keyArn = Prelude.Nothing} +instance ToResourceProperties ProviderProperty where + toResourceProperties ProviderProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.Provider", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "KeyArn" Prelude.<$> keyArn])} +instance JSON.ToJSON ProviderProperty where + toJSON ProviderProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "KeyArn" Prelude.<$> keyArn])) +instance Property "KeyArn" ProviderProperty where + type PropertyType "KeyArn" ProviderProperty = Value Prelude.Text + set newValue ProviderProperty {..} + = ProviderProperty {keyArn = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ProviderProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ProviderProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ProviderProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ProviderProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ProviderProperty :: Prelude.Type +instance ToResourceProperties ProviderProperty +instance Prelude.Eq ProviderProperty +instance Prelude.Show ProviderProperty +instance JSON.ToJSON ProviderProperty diff --git a/gen/Stratosphere/EKS/Cluster/RemoteNetworkConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/RemoteNetworkConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/RemoteNetworkConfigProperty.hs @@ -0,0 +1,51 @@ +module Stratosphere.EKS.Cluster.RemoteNetworkConfigProperty ( + module Exports, RemoteNetworkConfigProperty(..), + mkRemoteNetworkConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.RemoteNodeNetworkProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Cluster.RemotePodNetworkProperty as Exports +import Stratosphere.ResourceProperties +data RemoteNetworkConfigProperty + = -- | See: + RemoteNetworkConfigProperty {haddock_workaround_ :: (), + -- | See: + remoteNodeNetworks :: [RemoteNodeNetworkProperty], + -- | See: + remotePodNetworks :: (Prelude.Maybe [RemotePodNetworkProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkRemoteNetworkConfigProperty :: + [RemoteNodeNetworkProperty] -> RemoteNetworkConfigProperty +mkRemoteNetworkConfigProperty remoteNodeNetworks + = RemoteNetworkConfigProperty + {haddock_workaround_ = (), remoteNodeNetworks = remoteNodeNetworks, + remotePodNetworks = Prelude.Nothing} +instance ToResourceProperties RemoteNetworkConfigProperty where + toResourceProperties RemoteNetworkConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.RemoteNetworkConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["RemoteNodeNetworks" JSON..= remoteNodeNetworks] + (Prelude.catMaybes + [(JSON..=) "RemotePodNetworks" Prelude.<$> remotePodNetworks]))} +instance JSON.ToJSON RemoteNetworkConfigProperty where + toJSON RemoteNetworkConfigProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["RemoteNodeNetworks" JSON..= remoteNodeNetworks] + (Prelude.catMaybes + [(JSON..=) "RemotePodNetworks" Prelude.<$> remotePodNetworks]))) +instance Property "RemoteNodeNetworks" RemoteNetworkConfigProperty where + type PropertyType "RemoteNodeNetworks" RemoteNetworkConfigProperty = [RemoteNodeNetworkProperty] + set newValue RemoteNetworkConfigProperty {..} + = RemoteNetworkConfigProperty {remoteNodeNetworks = newValue, ..} +instance Property "RemotePodNetworks" RemoteNetworkConfigProperty where + type PropertyType "RemotePodNetworks" RemoteNetworkConfigProperty = [RemotePodNetworkProperty] + set newValue RemoteNetworkConfigProperty {..} + = RemoteNetworkConfigProperty + {remotePodNetworks = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/RemoteNetworkConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/RemoteNetworkConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/RemoteNetworkConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.RemoteNetworkConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RemoteNetworkConfigProperty :: Prelude.Type +instance ToResourceProperties RemoteNetworkConfigProperty +instance Prelude.Eq RemoteNetworkConfigProperty +instance Prelude.Show RemoteNetworkConfigProperty +instance JSON.ToJSON RemoteNetworkConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/RemoteNodeNetworkProperty.hs b/gen/Stratosphere/EKS/Cluster/RemoteNodeNetworkProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/RemoteNodeNetworkProperty.hs @@ -0,0 +1,31 @@ +module Stratosphere.EKS.Cluster.RemoteNodeNetworkProperty ( + RemoteNodeNetworkProperty(..), mkRemoteNodeNetworkProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RemoteNodeNetworkProperty + = -- | See: + RemoteNodeNetworkProperty {haddock_workaround_ :: (), + -- | See: + cidrs :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkRemoteNodeNetworkProperty :: + ValueList Prelude.Text -> RemoteNodeNetworkProperty +mkRemoteNodeNetworkProperty cidrs + = RemoteNodeNetworkProperty + {haddock_workaround_ = (), cidrs = cidrs} +instance ToResourceProperties RemoteNodeNetworkProperty where + toResourceProperties RemoteNodeNetworkProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.RemoteNodeNetwork", + supportsTags = Prelude.False, properties = ["Cidrs" JSON..= cidrs]} +instance JSON.ToJSON RemoteNodeNetworkProperty where + toJSON RemoteNodeNetworkProperty {..} + = JSON.object ["Cidrs" JSON..= cidrs] +instance Property "Cidrs" RemoteNodeNetworkProperty where + type PropertyType "Cidrs" RemoteNodeNetworkProperty = ValueList Prelude.Text + set newValue RemoteNodeNetworkProperty {..} + = RemoteNodeNetworkProperty {cidrs = newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/RemoteNodeNetworkProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/RemoteNodeNetworkProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/RemoteNodeNetworkProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.RemoteNodeNetworkProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RemoteNodeNetworkProperty :: Prelude.Type +instance ToResourceProperties RemoteNodeNetworkProperty +instance Prelude.Eq RemoteNodeNetworkProperty +instance Prelude.Show RemoteNodeNetworkProperty +instance JSON.ToJSON RemoteNodeNetworkProperty diff --git a/gen/Stratosphere/EKS/Cluster/RemotePodNetworkProperty.hs b/gen/Stratosphere/EKS/Cluster/RemotePodNetworkProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/RemotePodNetworkProperty.hs @@ -0,0 +1,31 @@ +module Stratosphere.EKS.Cluster.RemotePodNetworkProperty ( + RemotePodNetworkProperty(..), mkRemotePodNetworkProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RemotePodNetworkProperty + = -- | See: + RemotePodNetworkProperty {haddock_workaround_ :: (), + -- | See: + cidrs :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkRemotePodNetworkProperty :: + ValueList Prelude.Text -> RemotePodNetworkProperty +mkRemotePodNetworkProperty cidrs + = RemotePodNetworkProperty + {haddock_workaround_ = (), cidrs = cidrs} +instance ToResourceProperties RemotePodNetworkProperty where + toResourceProperties RemotePodNetworkProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.RemotePodNetwork", + supportsTags = Prelude.False, properties = ["Cidrs" JSON..= cidrs]} +instance JSON.ToJSON RemotePodNetworkProperty where + toJSON RemotePodNetworkProperty {..} + = JSON.object ["Cidrs" JSON..= cidrs] +instance Property "Cidrs" RemotePodNetworkProperty where + type PropertyType "Cidrs" RemotePodNetworkProperty = ValueList Prelude.Text + set newValue RemotePodNetworkProperty {..} + = RemotePodNetworkProperty {cidrs = newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/RemotePodNetworkProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/RemotePodNetworkProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/RemotePodNetworkProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.RemotePodNetworkProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RemotePodNetworkProperty :: Prelude.Type +instance ToResourceProperties RemotePodNetworkProperty +instance Prelude.Eq RemotePodNetworkProperty +instance Prelude.Show RemotePodNetworkProperty +instance JSON.ToJSON RemotePodNetworkProperty diff --git a/gen/Stratosphere/EKS/Cluster/ResourcesVpcConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/ResourcesVpcConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ResourcesVpcConfigProperty.hs @@ -0,0 +1,81 @@ +module Stratosphere.EKS.Cluster.ResourcesVpcConfigProperty ( + ResourcesVpcConfigProperty(..), mkResourcesVpcConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ResourcesVpcConfigProperty + = -- | See: + ResourcesVpcConfigProperty {haddock_workaround_ :: (), + -- | See: + endpointPrivateAccess :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + endpointPublicAccess :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + publicAccessCidrs :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + securityGroupIds :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + subnetIds :: (ValueList Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkResourcesVpcConfigProperty :: + ValueList Prelude.Text -> ResourcesVpcConfigProperty +mkResourcesVpcConfigProperty subnetIds + = ResourcesVpcConfigProperty + {haddock_workaround_ = (), subnetIds = subnetIds, + endpointPrivateAccess = Prelude.Nothing, + endpointPublicAccess = Prelude.Nothing, + publicAccessCidrs = Prelude.Nothing, + securityGroupIds = Prelude.Nothing} +instance ToResourceProperties ResourcesVpcConfigProperty where + toResourceProperties ResourcesVpcConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.ResourcesVpcConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["SubnetIds" JSON..= subnetIds] + (Prelude.catMaybes + [(JSON..=) "EndpointPrivateAccess" + Prelude.<$> endpointPrivateAccess, + (JSON..=) "EndpointPublicAccess" Prelude.<$> endpointPublicAccess, + (JSON..=) "PublicAccessCidrs" Prelude.<$> publicAccessCidrs, + (JSON..=) "SecurityGroupIds" Prelude.<$> securityGroupIds]))} +instance JSON.ToJSON ResourcesVpcConfigProperty where + toJSON ResourcesVpcConfigProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["SubnetIds" JSON..= subnetIds] + (Prelude.catMaybes + [(JSON..=) "EndpointPrivateAccess" + Prelude.<$> endpointPrivateAccess, + (JSON..=) "EndpointPublicAccess" Prelude.<$> endpointPublicAccess, + (JSON..=) "PublicAccessCidrs" Prelude.<$> publicAccessCidrs, + (JSON..=) "SecurityGroupIds" Prelude.<$> securityGroupIds]))) +instance Property "EndpointPrivateAccess" ResourcesVpcConfigProperty where + type PropertyType "EndpointPrivateAccess" ResourcesVpcConfigProperty = Value Prelude.Bool + set newValue ResourcesVpcConfigProperty {..} + = ResourcesVpcConfigProperty + {endpointPrivateAccess = Prelude.pure newValue, ..} +instance Property "EndpointPublicAccess" ResourcesVpcConfigProperty where + type PropertyType "EndpointPublicAccess" ResourcesVpcConfigProperty = Value Prelude.Bool + set newValue ResourcesVpcConfigProperty {..} + = ResourcesVpcConfigProperty + {endpointPublicAccess = Prelude.pure newValue, ..} +instance Property "PublicAccessCidrs" ResourcesVpcConfigProperty where + type PropertyType "PublicAccessCidrs" ResourcesVpcConfigProperty = ValueList Prelude.Text + set newValue ResourcesVpcConfigProperty {..} + = ResourcesVpcConfigProperty + {publicAccessCidrs = Prelude.pure newValue, ..} +instance Property "SecurityGroupIds" ResourcesVpcConfigProperty where + type PropertyType "SecurityGroupIds" ResourcesVpcConfigProperty = ValueList Prelude.Text + set newValue ResourcesVpcConfigProperty {..} + = ResourcesVpcConfigProperty + {securityGroupIds = Prelude.pure newValue, ..} +instance Property "SubnetIds" ResourcesVpcConfigProperty where + type PropertyType "SubnetIds" ResourcesVpcConfigProperty = ValueList Prelude.Text + set newValue ResourcesVpcConfigProperty {..} + = ResourcesVpcConfigProperty {subnetIds = newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ResourcesVpcConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ResourcesVpcConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ResourcesVpcConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ResourcesVpcConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ResourcesVpcConfigProperty :: Prelude.Type +instance ToResourceProperties ResourcesVpcConfigProperty +instance Prelude.Eq ResourcesVpcConfigProperty +instance Prelude.Show ResourcesVpcConfigProperty +instance JSON.ToJSON ResourcesVpcConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/StorageConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/StorageConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/StorageConfigProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.EKS.Cluster.StorageConfigProperty ( + module Exports, StorageConfigProperty(..), mkStorageConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Cluster.BlockStorageProperty as Exports +import Stratosphere.ResourceProperties +data StorageConfigProperty + = -- | See: + StorageConfigProperty {haddock_workaround_ :: (), + -- | See: + blockStorage :: (Prelude.Maybe BlockStorageProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkStorageConfigProperty :: StorageConfigProperty +mkStorageConfigProperty + = StorageConfigProperty + {haddock_workaround_ = (), blockStorage = Prelude.Nothing} +instance ToResourceProperties StorageConfigProperty where + toResourceProperties StorageConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.StorageConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "BlockStorage" Prelude.<$> blockStorage])} +instance JSON.ToJSON StorageConfigProperty where + toJSON StorageConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "BlockStorage" Prelude.<$> blockStorage])) +instance Property "BlockStorage" StorageConfigProperty where + type PropertyType "BlockStorage" StorageConfigProperty = BlockStorageProperty + set newValue StorageConfigProperty {..} + = StorageConfigProperty {blockStorage = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/StorageConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/StorageConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/StorageConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.StorageConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data StorageConfigProperty :: Prelude.Type +instance ToResourceProperties StorageConfigProperty +instance Prelude.Eq StorageConfigProperty +instance Prelude.Show StorageConfigProperty +instance JSON.ToJSON StorageConfigProperty diff --git a/gen/Stratosphere/EKS/Cluster/UpgradePolicyProperty.hs b/gen/Stratosphere/EKS/Cluster/UpgradePolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/UpgradePolicyProperty.hs @@ -0,0 +1,36 @@ +module Stratosphere.EKS.Cluster.UpgradePolicyProperty ( + UpgradePolicyProperty(..), mkUpgradePolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data UpgradePolicyProperty + = -- | See: + UpgradePolicyProperty {haddock_workaround_ :: (), + -- | See: + supportType :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkUpgradePolicyProperty :: UpgradePolicyProperty +mkUpgradePolicyProperty + = UpgradePolicyProperty + {haddock_workaround_ = (), supportType = Prelude.Nothing} +instance ToResourceProperties UpgradePolicyProperty where + toResourceProperties UpgradePolicyProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.UpgradePolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SupportType" Prelude.<$> supportType])} +instance JSON.ToJSON UpgradePolicyProperty where + toJSON UpgradePolicyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "SupportType" Prelude.<$> supportType])) +instance Property "SupportType" UpgradePolicyProperty where + type PropertyType "SupportType" UpgradePolicyProperty = Value Prelude.Text + set newValue UpgradePolicyProperty {..} + = UpgradePolicyProperty {supportType = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/UpgradePolicyProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/UpgradePolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/UpgradePolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.UpgradePolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data UpgradePolicyProperty :: Prelude.Type +instance ToResourceProperties UpgradePolicyProperty +instance Prelude.Eq UpgradePolicyProperty +instance Prelude.Show UpgradePolicyProperty +instance JSON.ToJSON UpgradePolicyProperty diff --git a/gen/Stratosphere/EKS/Cluster/ZonalShiftConfigProperty.hs b/gen/Stratosphere/EKS/Cluster/ZonalShiftConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ZonalShiftConfigProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.EKS.Cluster.ZonalShiftConfigProperty ( + ZonalShiftConfigProperty(..), mkZonalShiftConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ZonalShiftConfigProperty + = -- | See: + ZonalShiftConfigProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkZonalShiftConfigProperty :: ZonalShiftConfigProperty +mkZonalShiftConfigProperty + = ZonalShiftConfigProperty + {haddock_workaround_ = (), enabled = Prelude.Nothing} +instance ToResourceProperties ZonalShiftConfigProperty where + toResourceProperties ZonalShiftConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Cluster.ZonalShiftConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])} +instance JSON.ToJSON ZonalShiftConfigProperty where + toJSON ZonalShiftConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])) +instance Property "Enabled" ZonalShiftConfigProperty where + type PropertyType "Enabled" ZonalShiftConfigProperty = Value Prelude.Bool + set newValue ZonalShiftConfigProperty {..} + = ZonalShiftConfigProperty {enabled = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Cluster/ZonalShiftConfigProperty.hs-boot b/gen/Stratosphere/EKS/Cluster/ZonalShiftConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Cluster/ZonalShiftConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Cluster.ZonalShiftConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ZonalShiftConfigProperty :: Prelude.Type +instance ToResourceProperties ZonalShiftConfigProperty +instance Prelude.Eq ZonalShiftConfigProperty +instance Prelude.Show ZonalShiftConfigProperty +instance JSON.ToJSON ZonalShiftConfigProperty diff --git a/gen/Stratosphere/EKS/FargateProfile.hs b/gen/Stratosphere/EKS/FargateProfile.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/FargateProfile.hs @@ -0,0 +1,84 @@ +module Stratosphere.EKS.FargateProfile ( + module Exports, FargateProfile(..), mkFargateProfile + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.FargateProfile.SelectorProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data FargateProfile + = -- | See: + FargateProfile {haddock_workaround_ :: (), + -- | See: + clusterName :: (Value Prelude.Text), + -- | See: + fargateProfileName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + podExecutionRoleArn :: (Value Prelude.Text), + -- | See: + selectors :: [SelectorProperty], + -- | See: + subnets :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe [Tag])} + deriving stock (Prelude.Eq, Prelude.Show) +mkFargateProfile :: + Value Prelude.Text + -> Value Prelude.Text -> [SelectorProperty] -> FargateProfile +mkFargateProfile clusterName podExecutionRoleArn selectors + = FargateProfile + {haddock_workaround_ = (), clusterName = clusterName, + podExecutionRoleArn = podExecutionRoleArn, selectors = selectors, + fargateProfileName = Prelude.Nothing, subnets = Prelude.Nothing, + tags = Prelude.Nothing} +instance ToResourceProperties FargateProfile where + toResourceProperties FargateProfile {..} + = ResourceProperties + {awsType = "AWS::EKS::FargateProfile", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, + "PodExecutionRoleArn" JSON..= podExecutionRoleArn, + "Selectors" JSON..= selectors] + (Prelude.catMaybes + [(JSON..=) "FargateProfileName" Prelude.<$> fargateProfileName, + (JSON..=) "Subnets" Prelude.<$> subnets, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON FargateProfile where + toJSON FargateProfile {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, + "PodExecutionRoleArn" JSON..= podExecutionRoleArn, + "Selectors" JSON..= selectors] + (Prelude.catMaybes + [(JSON..=) "FargateProfileName" Prelude.<$> fargateProfileName, + (JSON..=) "Subnets" Prelude.<$> subnets, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "ClusterName" FargateProfile where + type PropertyType "ClusterName" FargateProfile = Value Prelude.Text + set newValue FargateProfile {..} + = FargateProfile {clusterName = newValue, ..} +instance Property "FargateProfileName" FargateProfile where + type PropertyType "FargateProfileName" FargateProfile = Value Prelude.Text + set newValue FargateProfile {..} + = FargateProfile {fargateProfileName = Prelude.pure newValue, ..} +instance Property "PodExecutionRoleArn" FargateProfile where + type PropertyType "PodExecutionRoleArn" FargateProfile = Value Prelude.Text + set newValue FargateProfile {..} + = FargateProfile {podExecutionRoleArn = newValue, ..} +instance Property "Selectors" FargateProfile where + type PropertyType "Selectors" FargateProfile = [SelectorProperty] + set newValue FargateProfile {..} + = FargateProfile {selectors = newValue, ..} +instance Property "Subnets" FargateProfile where + type PropertyType "Subnets" FargateProfile = ValueList Prelude.Text + set newValue FargateProfile {..} + = FargateProfile {subnets = Prelude.pure newValue, ..} +instance Property "Tags" FargateProfile where + type PropertyType "Tags" FargateProfile = [Tag] + set newValue FargateProfile {..} + = FargateProfile {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/FargateProfile/LabelProperty.hs b/gen/Stratosphere/EKS/FargateProfile/LabelProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/FargateProfile/LabelProperty.hs @@ -0,0 +1,38 @@ +module Stratosphere.EKS.FargateProfile.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::EKS::FargateProfile.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/EKS/FargateProfile/LabelProperty.hs-boot b/gen/Stratosphere/EKS/FargateProfile/LabelProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/FargateProfile/LabelProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.FargateProfile.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/EKS/FargateProfile/SelectorProperty.hs b/gen/Stratosphere/EKS/FargateProfile/SelectorProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/FargateProfile/SelectorProperty.hs @@ -0,0 +1,46 @@ +module Stratosphere.EKS.FargateProfile.SelectorProperty ( + module Exports, SelectorProperty(..), mkSelectorProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.FargateProfile.LabelProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data SelectorProperty + = -- | See: + SelectorProperty {haddock_workaround_ :: (), + -- | See: + labels :: (Prelude.Maybe [LabelProperty]), + -- | See: + namespace :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkSelectorProperty :: Value Prelude.Text -> SelectorProperty +mkSelectorProperty namespace + = SelectorProperty + {haddock_workaround_ = (), namespace = namespace, + labels = Prelude.Nothing} +instance ToResourceProperties SelectorProperty where + toResourceProperties SelectorProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::FargateProfile.Selector", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Namespace" JSON..= namespace] + (Prelude.catMaybes [(JSON..=) "Labels" Prelude.<$> labels]))} +instance JSON.ToJSON SelectorProperty where + toJSON SelectorProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Namespace" JSON..= namespace] + (Prelude.catMaybes [(JSON..=) "Labels" Prelude.<$> labels]))) +instance Property "Labels" SelectorProperty where + type PropertyType "Labels" SelectorProperty = [LabelProperty] + set newValue SelectorProperty {..} + = SelectorProperty {labels = Prelude.pure newValue, ..} +instance Property "Namespace" SelectorProperty where + type PropertyType "Namespace" SelectorProperty = Value Prelude.Text + set newValue SelectorProperty {..} + = SelectorProperty {namespace = newValue, ..} diff --git a/gen/Stratosphere/EKS/FargateProfile/SelectorProperty.hs-boot b/gen/Stratosphere/EKS/FargateProfile/SelectorProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/FargateProfile/SelectorProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.FargateProfile.SelectorProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data SelectorProperty :: Prelude.Type +instance ToResourceProperties SelectorProperty +instance Prelude.Eq SelectorProperty +instance Prelude.Show SelectorProperty +instance JSON.ToJSON SelectorProperty diff --git a/gen/Stratosphere/EKS/IdentityProviderConfig.hs b/gen/Stratosphere/EKS/IdentityProviderConfig.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/IdentityProviderConfig.hs @@ -0,0 +1,77 @@ +module Stratosphere.EKS.IdentityProviderConfig ( + module Exports, IdentityProviderConfig(..), + mkIdentityProviderConfig + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.IdentityProviderConfig.OidcIdentityProviderConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data IdentityProviderConfig + = -- | See: + IdentityProviderConfig {haddock_workaround_ :: (), + -- | See: + clusterName :: (Value Prelude.Text), + -- | See: + identityProviderConfigName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + oidc :: (Prelude.Maybe OidcIdentityProviderConfigProperty), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + type' :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkIdentityProviderConfig :: + Value Prelude.Text -> Value Prelude.Text -> IdentityProviderConfig +mkIdentityProviderConfig clusterName type' + = IdentityProviderConfig + {haddock_workaround_ = (), clusterName = clusterName, + type' = type', identityProviderConfigName = Prelude.Nothing, + oidc = Prelude.Nothing, tags = Prelude.Nothing} +instance ToResourceProperties IdentityProviderConfig where + toResourceProperties IdentityProviderConfig {..} + = ResourceProperties + {awsType = "AWS::EKS::IdentityProviderConfig", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, "Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "IdentityProviderConfigName" + Prelude.<$> identityProviderConfigName, + (JSON..=) "Oidc" Prelude.<$> oidc, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON IdentityProviderConfig where + toJSON IdentityProviderConfig {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, "Type" JSON..= type'] + (Prelude.catMaybes + [(JSON..=) "IdentityProviderConfigName" + Prelude.<$> identityProviderConfigName, + (JSON..=) "Oidc" Prelude.<$> oidc, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "ClusterName" IdentityProviderConfig where + type PropertyType "ClusterName" IdentityProviderConfig = Value Prelude.Text + set newValue IdentityProviderConfig {..} + = IdentityProviderConfig {clusterName = newValue, ..} +instance Property "IdentityProviderConfigName" IdentityProviderConfig where + type PropertyType "IdentityProviderConfigName" IdentityProviderConfig = Value Prelude.Text + set newValue IdentityProviderConfig {..} + = IdentityProviderConfig + {identityProviderConfigName = Prelude.pure newValue, ..} +instance Property "Oidc" IdentityProviderConfig where + type PropertyType "Oidc" IdentityProviderConfig = OidcIdentityProviderConfigProperty + set newValue IdentityProviderConfig {..} + = IdentityProviderConfig {oidc = Prelude.pure newValue, ..} +instance Property "Tags" IdentityProviderConfig where + type PropertyType "Tags" IdentityProviderConfig = [Tag] + set newValue IdentityProviderConfig {..} + = IdentityProviderConfig {tags = Prelude.pure newValue, ..} +instance Property "Type" IdentityProviderConfig where + type PropertyType "Type" IdentityProviderConfig = Value Prelude.Text + set newValue IdentityProviderConfig {..} + = IdentityProviderConfig {type' = newValue, ..} diff --git a/gen/Stratosphere/EKS/IdentityProviderConfig/OidcIdentityProviderConfigProperty.hs b/gen/Stratosphere/EKS/IdentityProviderConfig/OidcIdentityProviderConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/IdentityProviderConfig/OidcIdentityProviderConfigProperty.hs @@ -0,0 +1,96 @@ +module Stratosphere.EKS.IdentityProviderConfig.OidcIdentityProviderConfigProperty ( + module Exports, OidcIdentityProviderConfigProperty(..), + mkOidcIdentityProviderConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.IdentityProviderConfig.RequiredClaimProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data OidcIdentityProviderConfigProperty + = -- | See: + OidcIdentityProviderConfigProperty {haddock_workaround_ :: (), + -- | See: + clientId :: (Value Prelude.Text), + -- | See: + groupsClaim :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + groupsPrefix :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + issuerUrl :: (Value Prelude.Text), + -- | See: + requiredClaims :: (Prelude.Maybe [RequiredClaimProperty]), + -- | See: + usernameClaim :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + usernamePrefix :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkOidcIdentityProviderConfigProperty :: + Value Prelude.Text + -> Value Prelude.Text -> OidcIdentityProviderConfigProperty +mkOidcIdentityProviderConfigProperty clientId issuerUrl + = OidcIdentityProviderConfigProperty + {haddock_workaround_ = (), clientId = clientId, + issuerUrl = issuerUrl, groupsClaim = Prelude.Nothing, + groupsPrefix = Prelude.Nothing, requiredClaims = Prelude.Nothing, + usernameClaim = Prelude.Nothing, usernamePrefix = Prelude.Nothing} +instance ToResourceProperties OidcIdentityProviderConfigProperty where + toResourceProperties OidcIdentityProviderConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::IdentityProviderConfig.OidcIdentityProviderConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["ClientId" JSON..= clientId, "IssuerUrl" JSON..= issuerUrl] + (Prelude.catMaybes + [(JSON..=) "GroupsClaim" Prelude.<$> groupsClaim, + (JSON..=) "GroupsPrefix" Prelude.<$> groupsPrefix, + (JSON..=) "RequiredClaims" Prelude.<$> requiredClaims, + (JSON..=) "UsernameClaim" Prelude.<$> usernameClaim, + (JSON..=) "UsernamePrefix" Prelude.<$> usernamePrefix]))} +instance JSON.ToJSON OidcIdentityProviderConfigProperty where + toJSON OidcIdentityProviderConfigProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClientId" JSON..= clientId, "IssuerUrl" JSON..= issuerUrl] + (Prelude.catMaybes + [(JSON..=) "GroupsClaim" Prelude.<$> groupsClaim, + (JSON..=) "GroupsPrefix" Prelude.<$> groupsPrefix, + (JSON..=) "RequiredClaims" Prelude.<$> requiredClaims, + (JSON..=) "UsernameClaim" Prelude.<$> usernameClaim, + (JSON..=) "UsernamePrefix" Prelude.<$> usernamePrefix]))) +instance Property "ClientId" OidcIdentityProviderConfigProperty where + type PropertyType "ClientId" OidcIdentityProviderConfigProperty = Value Prelude.Text + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty {clientId = newValue, ..} +instance Property "GroupsClaim" OidcIdentityProviderConfigProperty where + type PropertyType "GroupsClaim" OidcIdentityProviderConfigProperty = Value Prelude.Text + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty + {groupsClaim = Prelude.pure newValue, ..} +instance Property "GroupsPrefix" OidcIdentityProviderConfigProperty where + type PropertyType "GroupsPrefix" OidcIdentityProviderConfigProperty = Value Prelude.Text + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty + {groupsPrefix = Prelude.pure newValue, ..} +instance Property "IssuerUrl" OidcIdentityProviderConfigProperty where + type PropertyType "IssuerUrl" OidcIdentityProviderConfigProperty = Value Prelude.Text + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty {issuerUrl = newValue, ..} +instance Property "RequiredClaims" OidcIdentityProviderConfigProperty where + type PropertyType "RequiredClaims" OidcIdentityProviderConfigProperty = [RequiredClaimProperty] + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty + {requiredClaims = Prelude.pure newValue, ..} +instance Property "UsernameClaim" OidcIdentityProviderConfigProperty where + type PropertyType "UsernameClaim" OidcIdentityProviderConfigProperty = Value Prelude.Text + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty + {usernameClaim = Prelude.pure newValue, ..} +instance Property "UsernamePrefix" OidcIdentityProviderConfigProperty where + type PropertyType "UsernamePrefix" OidcIdentityProviderConfigProperty = Value Prelude.Text + set newValue OidcIdentityProviderConfigProperty {..} + = OidcIdentityProviderConfigProperty + {usernamePrefix = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/IdentityProviderConfig/OidcIdentityProviderConfigProperty.hs-boot b/gen/Stratosphere/EKS/IdentityProviderConfig/OidcIdentityProviderConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/IdentityProviderConfig/OidcIdentityProviderConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.IdentityProviderConfig.OidcIdentityProviderConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data OidcIdentityProviderConfigProperty :: Prelude.Type +instance ToResourceProperties OidcIdentityProviderConfigProperty +instance Prelude.Eq OidcIdentityProviderConfigProperty +instance Prelude.Show OidcIdentityProviderConfigProperty +instance JSON.ToJSON OidcIdentityProviderConfigProperty diff --git a/gen/Stratosphere/EKS/IdentityProviderConfig/RequiredClaimProperty.hs b/gen/Stratosphere/EKS/IdentityProviderConfig/RequiredClaimProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/IdentityProviderConfig/RequiredClaimProperty.hs @@ -0,0 +1,38 @@ +module Stratosphere.EKS.IdentityProviderConfig.RequiredClaimProperty ( + RequiredClaimProperty(..), mkRequiredClaimProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RequiredClaimProperty + = -- | See: + RequiredClaimProperty {haddock_workaround_ :: (), + -- | See: + key :: (Value Prelude.Text), + -- | See: + value :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkRequiredClaimProperty :: + Value Prelude.Text -> Value Prelude.Text -> RequiredClaimProperty +mkRequiredClaimProperty key value + = RequiredClaimProperty + {haddock_workaround_ = (), key = key, value = value} +instance ToResourceProperties RequiredClaimProperty where + toResourceProperties RequiredClaimProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::IdentityProviderConfig.RequiredClaim", + supportsTags = Prelude.False, + properties = ["Key" JSON..= key, "Value" JSON..= value]} +instance JSON.ToJSON RequiredClaimProperty where + toJSON RequiredClaimProperty {..} + = JSON.object ["Key" JSON..= key, "Value" JSON..= value] +instance Property "Key" RequiredClaimProperty where + type PropertyType "Key" RequiredClaimProperty = Value Prelude.Text + set newValue RequiredClaimProperty {..} + = RequiredClaimProperty {key = newValue, ..} +instance Property "Value" RequiredClaimProperty where + type PropertyType "Value" RequiredClaimProperty = Value Prelude.Text + set newValue RequiredClaimProperty {..} + = RequiredClaimProperty {value = newValue, ..} diff --git a/gen/Stratosphere/EKS/IdentityProviderConfig/RequiredClaimProperty.hs-boot b/gen/Stratosphere/EKS/IdentityProviderConfig/RequiredClaimProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/IdentityProviderConfig/RequiredClaimProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.IdentityProviderConfig.RequiredClaimProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RequiredClaimProperty :: Prelude.Type +instance ToResourceProperties RequiredClaimProperty +instance Prelude.Eq RequiredClaimProperty +instance Prelude.Show RequiredClaimProperty +instance JSON.ToJSON RequiredClaimProperty diff --git a/gen/Stratosphere/EKS/Nodegroup.hs b/gen/Stratosphere/EKS/Nodegroup.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup.hs @@ -0,0 +1,195 @@ +module Stratosphere.EKS.Nodegroup ( + module Exports, Nodegroup(..), mkNodegroup + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EKS.Nodegroup.LaunchTemplateSpecificationProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Nodegroup.NodeRepairConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Nodegroup.RemoteAccessProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Nodegroup.ScalingConfigProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Nodegroup.TaintProperty as Exports +import {-# SOURCE #-} Stratosphere.EKS.Nodegroup.UpdateConfigProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data Nodegroup + = -- | See: + Nodegroup {haddock_workaround_ :: (), + -- | See: + amiType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + capacityType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + clusterName :: (Value Prelude.Text), + -- | See: + diskSize :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + forceUpdateEnabled :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + instanceTypes :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + labels :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + launchTemplate :: (Prelude.Maybe LaunchTemplateSpecificationProperty), + -- | See: + nodeRepairConfig :: (Prelude.Maybe NodeRepairConfigProperty), + -- | See: + nodeRole :: (Value Prelude.Text), + -- | See: + nodegroupName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + releaseVersion :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + remoteAccess :: (Prelude.Maybe RemoteAccessProperty), + -- | See: + scalingConfig :: (Prelude.Maybe ScalingConfigProperty), + -- | See: + subnets :: (ValueList Prelude.Text), + -- | See: + tags :: (Prelude.Maybe (Prelude.Map Prelude.Text (Value Prelude.Text))), + -- | See: + taints :: (Prelude.Maybe [TaintProperty]), + -- | See: + updateConfig :: (Prelude.Maybe UpdateConfigProperty), + -- | See: + version :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkNodegroup :: + Value Prelude.Text + -> Value Prelude.Text -> ValueList Prelude.Text -> Nodegroup +mkNodegroup clusterName nodeRole subnets + = Nodegroup + {haddock_workaround_ = (), clusterName = clusterName, + nodeRole = nodeRole, subnets = subnets, amiType = Prelude.Nothing, + capacityType = Prelude.Nothing, diskSize = Prelude.Nothing, + forceUpdateEnabled = Prelude.Nothing, + instanceTypes = Prelude.Nothing, labels = Prelude.Nothing, + launchTemplate = Prelude.Nothing, + nodeRepairConfig = Prelude.Nothing, + nodegroupName = Prelude.Nothing, releaseVersion = Prelude.Nothing, + remoteAccess = Prelude.Nothing, scalingConfig = Prelude.Nothing, + tags = Prelude.Nothing, taints = Prelude.Nothing, + updateConfig = Prelude.Nothing, version = Prelude.Nothing} +instance ToResourceProperties Nodegroup where + toResourceProperties Nodegroup {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup", supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, "NodeRole" JSON..= nodeRole, + "Subnets" JSON..= subnets] + (Prelude.catMaybes + [(JSON..=) "AmiType" Prelude.<$> amiType, + (JSON..=) "CapacityType" Prelude.<$> capacityType, + (JSON..=) "DiskSize" Prelude.<$> diskSize, + (JSON..=) "ForceUpdateEnabled" Prelude.<$> forceUpdateEnabled, + (JSON..=) "InstanceTypes" Prelude.<$> instanceTypes, + (JSON..=) "Labels" Prelude.<$> labels, + (JSON..=) "LaunchTemplate" Prelude.<$> launchTemplate, + (JSON..=) "NodeRepairConfig" Prelude.<$> nodeRepairConfig, + (JSON..=) "NodegroupName" Prelude.<$> nodegroupName, + (JSON..=) "ReleaseVersion" Prelude.<$> releaseVersion, + (JSON..=) "RemoteAccess" Prelude.<$> remoteAccess, + (JSON..=) "ScalingConfig" Prelude.<$> scalingConfig, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "Taints" Prelude.<$> taints, + (JSON..=) "UpdateConfig" Prelude.<$> updateConfig, + (JSON..=) "Version" Prelude.<$> version]))} +instance JSON.ToJSON Nodegroup where + toJSON Nodegroup {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, "NodeRole" JSON..= nodeRole, + "Subnets" JSON..= subnets] + (Prelude.catMaybes + [(JSON..=) "AmiType" Prelude.<$> amiType, + (JSON..=) "CapacityType" Prelude.<$> capacityType, + (JSON..=) "DiskSize" Prelude.<$> diskSize, + (JSON..=) "ForceUpdateEnabled" Prelude.<$> forceUpdateEnabled, + (JSON..=) "InstanceTypes" Prelude.<$> instanceTypes, + (JSON..=) "Labels" Prelude.<$> labels, + (JSON..=) "LaunchTemplate" Prelude.<$> launchTemplate, + (JSON..=) "NodeRepairConfig" Prelude.<$> nodeRepairConfig, + (JSON..=) "NodegroupName" Prelude.<$> nodegroupName, + (JSON..=) "ReleaseVersion" Prelude.<$> releaseVersion, + (JSON..=) "RemoteAccess" Prelude.<$> remoteAccess, + (JSON..=) "ScalingConfig" Prelude.<$> scalingConfig, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "Taints" Prelude.<$> taints, + (JSON..=) "UpdateConfig" Prelude.<$> updateConfig, + (JSON..=) "Version" Prelude.<$> version]))) +instance Property "AmiType" Nodegroup where + type PropertyType "AmiType" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {amiType = Prelude.pure newValue, ..} +instance Property "CapacityType" Nodegroup where + type PropertyType "CapacityType" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {capacityType = Prelude.pure newValue, ..} +instance Property "ClusterName" Nodegroup where + type PropertyType "ClusterName" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {clusterName = newValue, ..} +instance Property "DiskSize" Nodegroup where + type PropertyType "DiskSize" Nodegroup = Value Prelude.Integer + set newValue Nodegroup {..} + = Nodegroup {diskSize = Prelude.pure newValue, ..} +instance Property "ForceUpdateEnabled" Nodegroup where + type PropertyType "ForceUpdateEnabled" Nodegroup = Value Prelude.Bool + set newValue Nodegroup {..} + = Nodegroup {forceUpdateEnabled = Prelude.pure newValue, ..} +instance Property "InstanceTypes" Nodegroup where + type PropertyType "InstanceTypes" Nodegroup = ValueList Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {instanceTypes = Prelude.pure newValue, ..} +instance Property "Labels" Nodegroup where + type PropertyType "Labels" Nodegroup = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue Nodegroup {..} + = Nodegroup {labels = Prelude.pure newValue, ..} +instance Property "LaunchTemplate" Nodegroup where + type PropertyType "LaunchTemplate" Nodegroup = LaunchTemplateSpecificationProperty + set newValue Nodegroup {..} + = Nodegroup {launchTemplate = Prelude.pure newValue, ..} +instance Property "NodeRepairConfig" Nodegroup where + type PropertyType "NodeRepairConfig" Nodegroup = NodeRepairConfigProperty + set newValue Nodegroup {..} + = Nodegroup {nodeRepairConfig = Prelude.pure newValue, ..} +instance Property "NodeRole" Nodegroup where + type PropertyType "NodeRole" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} = Nodegroup {nodeRole = newValue, ..} +instance Property "NodegroupName" Nodegroup where + type PropertyType "NodegroupName" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {nodegroupName = Prelude.pure newValue, ..} +instance Property "ReleaseVersion" Nodegroup where + type PropertyType "ReleaseVersion" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {releaseVersion = Prelude.pure newValue, ..} +instance Property "RemoteAccess" Nodegroup where + type PropertyType "RemoteAccess" Nodegroup = RemoteAccessProperty + set newValue Nodegroup {..} + = Nodegroup {remoteAccess = Prelude.pure newValue, ..} +instance Property "ScalingConfig" Nodegroup where + type PropertyType "ScalingConfig" Nodegroup = ScalingConfigProperty + set newValue Nodegroup {..} + = Nodegroup {scalingConfig = Prelude.pure newValue, ..} +instance Property "Subnets" Nodegroup where + type PropertyType "Subnets" Nodegroup = ValueList Prelude.Text + set newValue Nodegroup {..} = Nodegroup {subnets = newValue, ..} +instance Property "Tags" Nodegroup where + type PropertyType "Tags" Nodegroup = Prelude.Map Prelude.Text (Value Prelude.Text) + set newValue Nodegroup {..} + = Nodegroup {tags = Prelude.pure newValue, ..} +instance Property "Taints" Nodegroup where + type PropertyType "Taints" Nodegroup = [TaintProperty] + set newValue Nodegroup {..} + = Nodegroup {taints = Prelude.pure newValue, ..} +instance Property "UpdateConfig" Nodegroup where + type PropertyType "UpdateConfig" Nodegroup = UpdateConfigProperty + set newValue Nodegroup {..} + = Nodegroup {updateConfig = Prelude.pure newValue, ..} +instance Property "Version" Nodegroup where + type PropertyType "Version" Nodegroup = Value Prelude.Text + set newValue Nodegroup {..} + = Nodegroup {version = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/LaunchTemplateSpecificationProperty.hs b/gen/Stratosphere/EKS/Nodegroup/LaunchTemplateSpecificationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/LaunchTemplateSpecificationProperty.hs @@ -0,0 +1,56 @@ +module Stratosphere.EKS.Nodegroup.LaunchTemplateSpecificationProperty ( + LaunchTemplateSpecificationProperty(..), + mkLaunchTemplateSpecificationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LaunchTemplateSpecificationProperty + = -- | See: + LaunchTemplateSpecificationProperty {haddock_workaround_ :: (), + -- | See: + id :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + name :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + version :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLaunchTemplateSpecificationProperty :: + LaunchTemplateSpecificationProperty +mkLaunchTemplateSpecificationProperty + = LaunchTemplateSpecificationProperty + {haddock_workaround_ = (), id = Prelude.Nothing, + name = Prelude.Nothing, version = Prelude.Nothing} +instance ToResourceProperties LaunchTemplateSpecificationProperty where + toResourceProperties LaunchTemplateSpecificationProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup.LaunchTemplateSpecification", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Id" Prelude.<$> id, (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Version" Prelude.<$> version])} +instance JSON.ToJSON LaunchTemplateSpecificationProperty where + toJSON LaunchTemplateSpecificationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Id" Prelude.<$> id, (JSON..=) "Name" Prelude.<$> name, + (JSON..=) "Version" Prelude.<$> version])) +instance Property "Id" LaunchTemplateSpecificationProperty where + type PropertyType "Id" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {id = Prelude.pure newValue, ..} +instance Property "Name" LaunchTemplateSpecificationProperty where + type PropertyType "Name" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {name = Prelude.pure newValue, ..} +instance Property "Version" LaunchTemplateSpecificationProperty where + type PropertyType "Version" LaunchTemplateSpecificationProperty = Value Prelude.Text + set newValue LaunchTemplateSpecificationProperty {..} + = LaunchTemplateSpecificationProperty + {version = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/LaunchTemplateSpecificationProperty.hs-boot b/gen/Stratosphere/EKS/Nodegroup/LaunchTemplateSpecificationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/LaunchTemplateSpecificationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Nodegroup.LaunchTemplateSpecificationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LaunchTemplateSpecificationProperty :: Prelude.Type +instance ToResourceProperties LaunchTemplateSpecificationProperty +instance Prelude.Eq LaunchTemplateSpecificationProperty +instance Prelude.Show LaunchTemplateSpecificationProperty +instance JSON.ToJSON LaunchTemplateSpecificationProperty diff --git a/gen/Stratosphere/EKS/Nodegroup/NodeRepairConfigProperty.hs b/gen/Stratosphere/EKS/Nodegroup/NodeRepairConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/NodeRepairConfigProperty.hs @@ -0,0 +1,34 @@ +module Stratosphere.EKS.Nodegroup.NodeRepairConfigProperty ( + NodeRepairConfigProperty(..), mkNodeRepairConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data NodeRepairConfigProperty + = -- | See: + NodeRepairConfigProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Prelude.Maybe (Value Prelude.Bool))} + deriving stock (Prelude.Eq, Prelude.Show) +mkNodeRepairConfigProperty :: NodeRepairConfigProperty +mkNodeRepairConfigProperty + = NodeRepairConfigProperty + {haddock_workaround_ = (), enabled = Prelude.Nothing} +instance ToResourceProperties NodeRepairConfigProperty where + toResourceProperties NodeRepairConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup.NodeRepairConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])} +instance JSON.ToJSON NodeRepairConfigProperty where + toJSON NodeRepairConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes [(JSON..=) "Enabled" Prelude.<$> enabled])) +instance Property "Enabled" NodeRepairConfigProperty where + type PropertyType "Enabled" NodeRepairConfigProperty = Value Prelude.Bool + set newValue NodeRepairConfigProperty {..} + = NodeRepairConfigProperty {enabled = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/NodeRepairConfigProperty.hs-boot b/gen/Stratosphere/EKS/Nodegroup/NodeRepairConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/NodeRepairConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Nodegroup.NodeRepairConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data NodeRepairConfigProperty :: Prelude.Type +instance ToResourceProperties NodeRepairConfigProperty +instance Prelude.Eq NodeRepairConfigProperty +instance Prelude.Show NodeRepairConfigProperty +instance JSON.ToJSON NodeRepairConfigProperty diff --git a/gen/Stratosphere/EKS/Nodegroup/RemoteAccessProperty.hs b/gen/Stratosphere/EKS/Nodegroup/RemoteAccessProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/RemoteAccessProperty.hs @@ -0,0 +1,51 @@ +module Stratosphere.EKS.Nodegroup.RemoteAccessProperty ( + RemoteAccessProperty(..), mkRemoteAccessProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RemoteAccessProperty + = -- | See: + RemoteAccessProperty {haddock_workaround_ :: (), + -- | See: + ec2SshKey :: (Value Prelude.Text), + -- | See: + sourceSecurityGroups :: (Prelude.Maybe (ValueList Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkRemoteAccessProperty :: + Value Prelude.Text -> RemoteAccessProperty +mkRemoteAccessProperty ec2SshKey + = RemoteAccessProperty + {haddock_workaround_ = (), ec2SshKey = ec2SshKey, + sourceSecurityGroups = Prelude.Nothing} +instance ToResourceProperties RemoteAccessProperty where + toResourceProperties RemoteAccessProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup.RemoteAccess", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Ec2SshKey" JSON..= ec2SshKey] + (Prelude.catMaybes + [(JSON..=) "SourceSecurityGroups" + Prelude.<$> sourceSecurityGroups]))} +instance JSON.ToJSON RemoteAccessProperty where + toJSON RemoteAccessProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Ec2SshKey" JSON..= ec2SshKey] + (Prelude.catMaybes + [(JSON..=) "SourceSecurityGroups" + Prelude.<$> sourceSecurityGroups]))) +instance Property "Ec2SshKey" RemoteAccessProperty where + type PropertyType "Ec2SshKey" RemoteAccessProperty = Value Prelude.Text + set newValue RemoteAccessProperty {..} + = RemoteAccessProperty {ec2SshKey = newValue, ..} +instance Property "SourceSecurityGroups" RemoteAccessProperty where + type PropertyType "SourceSecurityGroups" RemoteAccessProperty = ValueList Prelude.Text + set newValue RemoteAccessProperty {..} + = RemoteAccessProperty + {sourceSecurityGroups = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/RemoteAccessProperty.hs-boot b/gen/Stratosphere/EKS/Nodegroup/RemoteAccessProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/RemoteAccessProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Nodegroup.RemoteAccessProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RemoteAccessProperty :: Prelude.Type +instance ToResourceProperties RemoteAccessProperty +instance Prelude.Eq RemoteAccessProperty +instance Prelude.Show RemoteAccessProperty +instance JSON.ToJSON RemoteAccessProperty diff --git a/gen/Stratosphere/EKS/Nodegroup/ScalingConfigProperty.hs b/gen/Stratosphere/EKS/Nodegroup/ScalingConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/ScalingConfigProperty.hs @@ -0,0 +1,53 @@ +module Stratosphere.EKS.Nodegroup.ScalingConfigProperty ( + ScalingConfigProperty(..), mkScalingConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ScalingConfigProperty + = -- | See: + ScalingConfigProperty {haddock_workaround_ :: (), + -- | See: + desiredSize :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + maxSize :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + minSize :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkScalingConfigProperty :: ScalingConfigProperty +mkScalingConfigProperty + = ScalingConfigProperty + {haddock_workaround_ = (), desiredSize = Prelude.Nothing, + maxSize = Prelude.Nothing, minSize = Prelude.Nothing} +instance ToResourceProperties ScalingConfigProperty where + toResourceProperties ScalingConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup.ScalingConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "DesiredSize" Prelude.<$> desiredSize, + (JSON..=) "MaxSize" Prelude.<$> maxSize, + (JSON..=) "MinSize" Prelude.<$> minSize])} +instance JSON.ToJSON ScalingConfigProperty where + toJSON ScalingConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "DesiredSize" Prelude.<$> desiredSize, + (JSON..=) "MaxSize" Prelude.<$> maxSize, + (JSON..=) "MinSize" Prelude.<$> minSize])) +instance Property "DesiredSize" ScalingConfigProperty where + type PropertyType "DesiredSize" ScalingConfigProperty = Value Prelude.Integer + set newValue ScalingConfigProperty {..} + = ScalingConfigProperty {desiredSize = Prelude.pure newValue, ..} +instance Property "MaxSize" ScalingConfigProperty where + type PropertyType "MaxSize" ScalingConfigProperty = Value Prelude.Integer + set newValue ScalingConfigProperty {..} + = ScalingConfigProperty {maxSize = Prelude.pure newValue, ..} +instance Property "MinSize" ScalingConfigProperty where + type PropertyType "MinSize" ScalingConfigProperty = Value Prelude.Integer + set newValue ScalingConfigProperty {..} + = ScalingConfigProperty {minSize = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/ScalingConfigProperty.hs-boot b/gen/Stratosphere/EKS/Nodegroup/ScalingConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/ScalingConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Nodegroup.ScalingConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ScalingConfigProperty :: Prelude.Type +instance ToResourceProperties ScalingConfigProperty +instance Prelude.Eq ScalingConfigProperty +instance Prelude.Show ScalingConfigProperty +instance JSON.ToJSON ScalingConfigProperty diff --git a/gen/Stratosphere/EKS/Nodegroup/TaintProperty.hs b/gen/Stratosphere/EKS/Nodegroup/TaintProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/TaintProperty.hs @@ -0,0 +1,53 @@ +module Stratosphere.EKS.Nodegroup.TaintProperty ( + TaintProperty(..), mkTaintProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data TaintProperty + = -- | See: + TaintProperty {haddock_workaround_ :: (), + -- | See: + effect :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + key :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + value :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkTaintProperty :: TaintProperty +mkTaintProperty + = TaintProperty + {haddock_workaround_ = (), effect = Prelude.Nothing, + key = Prelude.Nothing, value = Prelude.Nothing} +instance ToResourceProperties TaintProperty where + toResourceProperties TaintProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup.Taint", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Effect" Prelude.<$> effect, + (JSON..=) "Key" Prelude.<$> key, + (JSON..=) "Value" Prelude.<$> value])} +instance JSON.ToJSON TaintProperty where + toJSON TaintProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Effect" Prelude.<$> effect, + (JSON..=) "Key" Prelude.<$> key, + (JSON..=) "Value" Prelude.<$> value])) +instance Property "Effect" TaintProperty where + type PropertyType "Effect" TaintProperty = Value Prelude.Text + set newValue TaintProperty {..} + = TaintProperty {effect = Prelude.pure newValue, ..} +instance Property "Key" TaintProperty where + type PropertyType "Key" TaintProperty = Value Prelude.Text + set newValue TaintProperty {..} + = TaintProperty {key = Prelude.pure newValue, ..} +instance Property "Value" TaintProperty where + type PropertyType "Value" TaintProperty = Value Prelude.Text + set newValue TaintProperty {..} + = TaintProperty {value = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/TaintProperty.hs-boot b/gen/Stratosphere/EKS/Nodegroup/TaintProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/TaintProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Nodegroup.TaintProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data TaintProperty :: Prelude.Type +instance ToResourceProperties TaintProperty +instance Prelude.Eq TaintProperty +instance Prelude.Show TaintProperty +instance JSON.ToJSON TaintProperty diff --git a/gen/Stratosphere/EKS/Nodegroup/UpdateConfigProperty.hs b/gen/Stratosphere/EKS/Nodegroup/UpdateConfigProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/UpdateConfigProperty.hs @@ -0,0 +1,57 @@ +module Stratosphere.EKS.Nodegroup.UpdateConfigProperty ( + UpdateConfigProperty(..), mkUpdateConfigProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data UpdateConfigProperty + = -- | See: + UpdateConfigProperty {haddock_workaround_ :: (), + -- | See: + maxUnavailable :: (Prelude.Maybe (Value Prelude.Double)), + -- | See: + maxUnavailablePercentage :: (Prelude.Maybe (Value Prelude.Double)), + -- | See: + updateStrategy :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkUpdateConfigProperty :: UpdateConfigProperty +mkUpdateConfigProperty + = UpdateConfigProperty + {haddock_workaround_ = (), maxUnavailable = Prelude.Nothing, + maxUnavailablePercentage = Prelude.Nothing, + updateStrategy = Prelude.Nothing} +instance ToResourceProperties UpdateConfigProperty where + toResourceProperties UpdateConfigProperty {..} + = ResourceProperties + {awsType = "AWS::EKS::Nodegroup.UpdateConfig", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "MaxUnavailable" Prelude.<$> maxUnavailable, + (JSON..=) "MaxUnavailablePercentage" + Prelude.<$> maxUnavailablePercentage, + (JSON..=) "UpdateStrategy" Prelude.<$> updateStrategy])} +instance JSON.ToJSON UpdateConfigProperty where + toJSON UpdateConfigProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "MaxUnavailable" Prelude.<$> maxUnavailable, + (JSON..=) "MaxUnavailablePercentage" + Prelude.<$> maxUnavailablePercentage, + (JSON..=) "UpdateStrategy" Prelude.<$> updateStrategy])) +instance Property "MaxUnavailable" UpdateConfigProperty where + type PropertyType "MaxUnavailable" UpdateConfigProperty = Value Prelude.Double + set newValue UpdateConfigProperty {..} + = UpdateConfigProperty {maxUnavailable = Prelude.pure newValue, ..} +instance Property "MaxUnavailablePercentage" UpdateConfigProperty where + type PropertyType "MaxUnavailablePercentage" UpdateConfigProperty = Value Prelude.Double + set newValue UpdateConfigProperty {..} + = UpdateConfigProperty + {maxUnavailablePercentage = Prelude.pure newValue, ..} +instance Property "UpdateStrategy" UpdateConfigProperty where + type PropertyType "UpdateStrategy" UpdateConfigProperty = Value Prelude.Text + set newValue UpdateConfigProperty {..} + = UpdateConfigProperty {updateStrategy = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EKS/Nodegroup/UpdateConfigProperty.hs-boot b/gen/Stratosphere/EKS/Nodegroup/UpdateConfigProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/Nodegroup/UpdateConfigProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EKS.Nodegroup.UpdateConfigProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data UpdateConfigProperty :: Prelude.Type +instance ToResourceProperties UpdateConfigProperty +instance Prelude.Eq UpdateConfigProperty +instance Prelude.Show UpdateConfigProperty +instance JSON.ToJSON UpdateConfigProperty diff --git a/gen/Stratosphere/EKS/PodIdentityAssociation.hs b/gen/Stratosphere/EKS/PodIdentityAssociation.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EKS/PodIdentityAssociation.hs @@ -0,0 +1,97 @@ +module Stratosphere.EKS.PodIdentityAssociation ( + PodIdentityAssociation(..), mkPodIdentityAssociation + ) 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 PodIdentityAssociation + = -- | See: + PodIdentityAssociation {haddock_workaround_ :: (), + -- | See: + clusterName :: (Value Prelude.Text), + -- | See: + disableSessionTags :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + namespace :: (Value Prelude.Text), + -- | See: + roleArn :: (Value Prelude.Text), + -- | See: + serviceAccount :: (Value Prelude.Text), + -- | See: + tags :: (Prelude.Maybe [Tag]), + -- | See: + targetRoleArn :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkPodIdentityAssociation :: + Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text -> PodIdentityAssociation +mkPodIdentityAssociation + clusterName + namespace + roleArn + serviceAccount + = PodIdentityAssociation + {haddock_workaround_ = (), clusterName = clusterName, + namespace = namespace, roleArn = roleArn, + serviceAccount = serviceAccount, + disableSessionTags = Prelude.Nothing, tags = Prelude.Nothing, + targetRoleArn = Prelude.Nothing} +instance ToResourceProperties PodIdentityAssociation where + toResourceProperties PodIdentityAssociation {..} + = ResourceProperties + {awsType = "AWS::EKS::PodIdentityAssociation", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, "Namespace" JSON..= namespace, + "RoleArn" JSON..= roleArn, "ServiceAccount" JSON..= serviceAccount] + (Prelude.catMaybes + [(JSON..=) "DisableSessionTags" Prelude.<$> disableSessionTags, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "TargetRoleArn" Prelude.<$> targetRoleArn]))} +instance JSON.ToJSON PodIdentityAssociation where + toJSON PodIdentityAssociation {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["ClusterName" JSON..= clusterName, "Namespace" JSON..= namespace, + "RoleArn" JSON..= roleArn, "ServiceAccount" JSON..= serviceAccount] + (Prelude.catMaybes + [(JSON..=) "DisableSessionTags" Prelude.<$> disableSessionTags, + (JSON..=) "Tags" Prelude.<$> tags, + (JSON..=) "TargetRoleArn" Prelude.<$> targetRoleArn]))) +instance Property "ClusterName" PodIdentityAssociation where + type PropertyType "ClusterName" PodIdentityAssociation = Value Prelude.Text + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation {clusterName = newValue, ..} +instance Property "DisableSessionTags" PodIdentityAssociation where + type PropertyType "DisableSessionTags" PodIdentityAssociation = Value Prelude.Bool + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation + {disableSessionTags = Prelude.pure newValue, ..} +instance Property "Namespace" PodIdentityAssociation where + type PropertyType "Namespace" PodIdentityAssociation = Value Prelude.Text + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation {namespace = newValue, ..} +instance Property "RoleArn" PodIdentityAssociation where + type PropertyType "RoleArn" PodIdentityAssociation = Value Prelude.Text + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation {roleArn = newValue, ..} +instance Property "ServiceAccount" PodIdentityAssociation where + type PropertyType "ServiceAccount" PodIdentityAssociation = Value Prelude.Text + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation {serviceAccount = newValue, ..} +instance Property "Tags" PodIdentityAssociation where + type PropertyType "Tags" PodIdentityAssociation = [Tag] + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation {tags = Prelude.pure newValue, ..} +instance Property "TargetRoleArn" PodIdentityAssociation where + type PropertyType "TargetRoleArn" PodIdentityAssociation = Value Prelude.Text + set newValue PodIdentityAssociation {..} + = PodIdentityAssociation + {targetRoleArn = Prelude.pure newValue, ..} diff --git a/stratosphere-eks.cabal b/stratosphere-eks.cabal new file mode 100644 --- /dev/null +++ b/stratosphere-eks.cabal @@ -0,0 +1,112 @@ +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-eks +version: 1.0.0 +synopsis: Stratosphere integration for AWS EKS. +description: Integration into stratosphere to generate resources and properties for AWS EKS +category: AWS, Cloud, EKS +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.EKS.AccessEntry + Stratosphere.EKS.AccessEntry.AccessPolicyProperty + Stratosphere.EKS.AccessEntry.AccessScopeProperty + Stratosphere.EKS.Addon + Stratosphere.EKS.Addon.NamespaceConfigProperty + Stratosphere.EKS.Addon.PodIdentityAssociationProperty + Stratosphere.EKS.Cluster + Stratosphere.EKS.Cluster.AccessConfigProperty + Stratosphere.EKS.Cluster.BlockStorageProperty + Stratosphere.EKS.Cluster.ClusterLoggingProperty + Stratosphere.EKS.Cluster.ComputeConfigProperty + Stratosphere.EKS.Cluster.ControlPlanePlacementProperty + Stratosphere.EKS.Cluster.ElasticLoadBalancingProperty + Stratosphere.EKS.Cluster.EncryptionConfigProperty + Stratosphere.EKS.Cluster.KubernetesNetworkConfigProperty + Stratosphere.EKS.Cluster.LoggingProperty + Stratosphere.EKS.Cluster.LoggingTypeConfigProperty + Stratosphere.EKS.Cluster.OutpostConfigProperty + Stratosphere.EKS.Cluster.ProviderProperty + Stratosphere.EKS.Cluster.RemoteNetworkConfigProperty + Stratosphere.EKS.Cluster.RemoteNodeNetworkProperty + Stratosphere.EKS.Cluster.RemotePodNetworkProperty + Stratosphere.EKS.Cluster.ResourcesVpcConfigProperty + Stratosphere.EKS.Cluster.StorageConfigProperty + Stratosphere.EKS.Cluster.UpgradePolicyProperty + Stratosphere.EKS.Cluster.ZonalShiftConfigProperty + Stratosphere.EKS.FargateProfile + Stratosphere.EKS.FargateProfile.LabelProperty + Stratosphere.EKS.FargateProfile.SelectorProperty + Stratosphere.EKS.IdentityProviderConfig + Stratosphere.EKS.IdentityProviderConfig.OidcIdentityProviderConfigProperty + Stratosphere.EKS.IdentityProviderConfig.RequiredClaimProperty + Stratosphere.EKS.Nodegroup + Stratosphere.EKS.Nodegroup.LaunchTemplateSpecificationProperty + Stratosphere.EKS.Nodegroup.NodeRepairConfigProperty + Stratosphere.EKS.Nodegroup.RemoteAccessProperty + Stratosphere.EKS.Nodegroup.ScalingConfigProperty + Stratosphere.EKS.Nodegroup.TaintProperty + Stratosphere.EKS.Nodegroup.UpdateConfigProperty + Stratosphere.EKS.PodIdentityAssociation + other-modules: + Paths_stratosphere_eks + 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