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/ElasticLoadBalancing/LoadBalancer.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer.hs @@ -0,0 +1,186 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer ( + module Exports, LoadBalancer(..), mkLoadBalancer + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.AccessLoggingPolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.AppCookieStickinessPolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionDrainingPolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionSettingsProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.HealthCheckProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.LBCookieStickinessPolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.ListenersProperty as Exports +import {-# SOURCE #-} Stratosphere.ElasticLoadBalancing.LoadBalancer.PoliciesProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Tag +import Stratosphere.Value +data LoadBalancer + = -- | See: + LoadBalancer {haddock_workaround_ :: (), + -- | See: + accessLoggingPolicy :: (Prelude.Maybe AccessLoggingPolicyProperty), + -- | See: + appCookieStickinessPolicy :: (Prelude.Maybe [AppCookieStickinessPolicyProperty]), + -- | See: + availabilityZones :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + connectionDrainingPolicy :: (Prelude.Maybe ConnectionDrainingPolicyProperty), + -- | See: + connectionSettings :: (Prelude.Maybe ConnectionSettingsProperty), + -- | See: + crossZone :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + healthCheck :: (Prelude.Maybe HealthCheckProperty), + -- | See: + instances :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + lBCookieStickinessPolicy :: (Prelude.Maybe [LBCookieStickinessPolicyProperty]), + -- | See: + listeners :: [ListenersProperty], + -- | See: + loadBalancerName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + policies :: (Prelude.Maybe [PoliciesProperty]), + -- | See: + scheme :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + securityGroups :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + subnets :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + tags :: (Prelude.Maybe [Tag])} + deriving stock (Prelude.Eq, Prelude.Show) +mkLoadBalancer :: [ListenersProperty] -> LoadBalancer +mkLoadBalancer listeners + = LoadBalancer + {haddock_workaround_ = (), listeners = listeners, + accessLoggingPolicy = Prelude.Nothing, + appCookieStickinessPolicy = Prelude.Nothing, + availabilityZones = Prelude.Nothing, + connectionDrainingPolicy = Prelude.Nothing, + connectionSettings = Prelude.Nothing, crossZone = Prelude.Nothing, + healthCheck = Prelude.Nothing, instances = Prelude.Nothing, + lBCookieStickinessPolicy = Prelude.Nothing, + loadBalancerName = Prelude.Nothing, policies = Prelude.Nothing, + scheme = Prelude.Nothing, securityGroups = Prelude.Nothing, + subnets = Prelude.Nothing, tags = Prelude.Nothing} +instance ToResourceProperties LoadBalancer where + toResourceProperties LoadBalancer {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer", + supportsTags = Prelude.True, + properties = Prelude.fromList + ((Prelude.<>) + ["Listeners" JSON..= listeners] + (Prelude.catMaybes + [(JSON..=) "AccessLoggingPolicy" Prelude.<$> accessLoggingPolicy, + (JSON..=) "AppCookieStickinessPolicy" + Prelude.<$> appCookieStickinessPolicy, + (JSON..=) "AvailabilityZones" Prelude.<$> availabilityZones, + (JSON..=) "ConnectionDrainingPolicy" + Prelude.<$> connectionDrainingPolicy, + (JSON..=) "ConnectionSettings" Prelude.<$> connectionSettings, + (JSON..=) "CrossZone" Prelude.<$> crossZone, + (JSON..=) "HealthCheck" Prelude.<$> healthCheck, + (JSON..=) "Instances" Prelude.<$> instances, + (JSON..=) "LBCookieStickinessPolicy" + Prelude.<$> lBCookieStickinessPolicy, + (JSON..=) "LoadBalancerName" Prelude.<$> loadBalancerName, + (JSON..=) "Policies" Prelude.<$> policies, + (JSON..=) "Scheme" Prelude.<$> scheme, + (JSON..=) "SecurityGroups" Prelude.<$> securityGroups, + (JSON..=) "Subnets" Prelude.<$> subnets, + (JSON..=) "Tags" Prelude.<$> tags]))} +instance JSON.ToJSON LoadBalancer where + toJSON LoadBalancer {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Listeners" JSON..= listeners] + (Prelude.catMaybes + [(JSON..=) "AccessLoggingPolicy" Prelude.<$> accessLoggingPolicy, + (JSON..=) "AppCookieStickinessPolicy" + Prelude.<$> appCookieStickinessPolicy, + (JSON..=) "AvailabilityZones" Prelude.<$> availabilityZones, + (JSON..=) "ConnectionDrainingPolicy" + Prelude.<$> connectionDrainingPolicy, + (JSON..=) "ConnectionSettings" Prelude.<$> connectionSettings, + (JSON..=) "CrossZone" Prelude.<$> crossZone, + (JSON..=) "HealthCheck" Prelude.<$> healthCheck, + (JSON..=) "Instances" Prelude.<$> instances, + (JSON..=) "LBCookieStickinessPolicy" + Prelude.<$> lBCookieStickinessPolicy, + (JSON..=) "LoadBalancerName" Prelude.<$> loadBalancerName, + (JSON..=) "Policies" Prelude.<$> policies, + (JSON..=) "Scheme" Prelude.<$> scheme, + (JSON..=) "SecurityGroups" Prelude.<$> securityGroups, + (JSON..=) "Subnets" Prelude.<$> subnets, + (JSON..=) "Tags" Prelude.<$> tags]))) +instance Property "AccessLoggingPolicy" LoadBalancer where + type PropertyType "AccessLoggingPolicy" LoadBalancer = AccessLoggingPolicyProperty + set newValue LoadBalancer {..} + = LoadBalancer {accessLoggingPolicy = Prelude.pure newValue, ..} +instance Property "AppCookieStickinessPolicy" LoadBalancer where + type PropertyType "AppCookieStickinessPolicy" LoadBalancer = [AppCookieStickinessPolicyProperty] + set newValue LoadBalancer {..} + = LoadBalancer + {appCookieStickinessPolicy = Prelude.pure newValue, ..} +instance Property "AvailabilityZones" LoadBalancer where + type PropertyType "AvailabilityZones" LoadBalancer = ValueList Prelude.Text + set newValue LoadBalancer {..} + = LoadBalancer {availabilityZones = Prelude.pure newValue, ..} +instance Property "ConnectionDrainingPolicy" LoadBalancer where + type PropertyType "ConnectionDrainingPolicy" LoadBalancer = ConnectionDrainingPolicyProperty + set newValue LoadBalancer {..} + = LoadBalancer + {connectionDrainingPolicy = Prelude.pure newValue, ..} +instance Property "ConnectionSettings" LoadBalancer where + type PropertyType "ConnectionSettings" LoadBalancer = ConnectionSettingsProperty + set newValue LoadBalancer {..} + = LoadBalancer {connectionSettings = Prelude.pure newValue, ..} +instance Property "CrossZone" LoadBalancer where + type PropertyType "CrossZone" LoadBalancer = Value Prelude.Bool + set newValue LoadBalancer {..} + = LoadBalancer {crossZone = Prelude.pure newValue, ..} +instance Property "HealthCheck" LoadBalancer where + type PropertyType "HealthCheck" LoadBalancer = HealthCheckProperty + set newValue LoadBalancer {..} + = LoadBalancer {healthCheck = Prelude.pure newValue, ..} +instance Property "Instances" LoadBalancer where + type PropertyType "Instances" LoadBalancer = ValueList Prelude.Text + set newValue LoadBalancer {..} + = LoadBalancer {instances = Prelude.pure newValue, ..} +instance Property "LBCookieStickinessPolicy" LoadBalancer where + type PropertyType "LBCookieStickinessPolicy" LoadBalancer = [LBCookieStickinessPolicyProperty] + set newValue LoadBalancer {..} + = LoadBalancer + {lBCookieStickinessPolicy = Prelude.pure newValue, ..} +instance Property "Listeners" LoadBalancer where + type PropertyType "Listeners" LoadBalancer = [ListenersProperty] + set newValue LoadBalancer {..} + = LoadBalancer {listeners = newValue, ..} +instance Property "LoadBalancerName" LoadBalancer where + type PropertyType "LoadBalancerName" LoadBalancer = Value Prelude.Text + set newValue LoadBalancer {..} + = LoadBalancer {loadBalancerName = Prelude.pure newValue, ..} +instance Property "Policies" LoadBalancer where + type PropertyType "Policies" LoadBalancer = [PoliciesProperty] + set newValue LoadBalancer {..} + = LoadBalancer {policies = Prelude.pure newValue, ..} +instance Property "Scheme" LoadBalancer where + type PropertyType "Scheme" LoadBalancer = Value Prelude.Text + set newValue LoadBalancer {..} + = LoadBalancer {scheme = Prelude.pure newValue, ..} +instance Property "SecurityGroups" LoadBalancer where + type PropertyType "SecurityGroups" LoadBalancer = ValueList Prelude.Text + set newValue LoadBalancer {..} + = LoadBalancer {securityGroups = Prelude.pure newValue, ..} +instance Property "Subnets" LoadBalancer where + type PropertyType "Subnets" LoadBalancer = ValueList Prelude.Text + set newValue LoadBalancer {..} + = LoadBalancer {subnets = Prelude.pure newValue, ..} +instance Property "Tags" LoadBalancer where + type PropertyType "Tags" LoadBalancer = [Tag] + set newValue LoadBalancer {..} + = LoadBalancer {tags = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AccessLoggingPolicyProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AccessLoggingPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AccessLoggingPolicyProperty.hs @@ -0,0 +1,66 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.AccessLoggingPolicyProperty ( + AccessLoggingPolicyProperty(..), mkAccessLoggingPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AccessLoggingPolicyProperty + = -- | See: + AccessLoggingPolicyProperty {haddock_workaround_ :: (), + -- | See: + emitInterval :: (Prelude.Maybe (Value Prelude.Integer)), + -- | See: + enabled :: (Value Prelude.Bool), + -- | See: + s3BucketName :: (Value Prelude.Text), + -- | See: + s3BucketPrefix :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessLoggingPolicyProperty :: + Value Prelude.Bool + -> Value Prelude.Text -> AccessLoggingPolicyProperty +mkAccessLoggingPolicyProperty enabled s3BucketName + = AccessLoggingPolicyProperty + {haddock_workaround_ = (), enabled = enabled, + s3BucketName = s3BucketName, emitInterval = Prelude.Nothing, + s3BucketPrefix = Prelude.Nothing} +instance ToResourceProperties AccessLoggingPolicyProperty where + toResourceProperties AccessLoggingPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.AccessLoggingPolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Enabled" JSON..= enabled, "S3BucketName" JSON..= s3BucketName] + (Prelude.catMaybes + [(JSON..=) "EmitInterval" Prelude.<$> emitInterval, + (JSON..=) "S3BucketPrefix" Prelude.<$> s3BucketPrefix]))} +instance JSON.ToJSON AccessLoggingPolicyProperty where + toJSON AccessLoggingPolicyProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Enabled" JSON..= enabled, "S3BucketName" JSON..= s3BucketName] + (Prelude.catMaybes + [(JSON..=) "EmitInterval" Prelude.<$> emitInterval, + (JSON..=) "S3BucketPrefix" Prelude.<$> s3BucketPrefix]))) +instance Property "EmitInterval" AccessLoggingPolicyProperty where + type PropertyType "EmitInterval" AccessLoggingPolicyProperty = Value Prelude.Integer + set newValue AccessLoggingPolicyProperty {..} + = AccessLoggingPolicyProperty + {emitInterval = Prelude.pure newValue, ..} +instance Property "Enabled" AccessLoggingPolicyProperty where + type PropertyType "Enabled" AccessLoggingPolicyProperty = Value Prelude.Bool + set newValue AccessLoggingPolicyProperty {..} + = AccessLoggingPolicyProperty {enabled = newValue, ..} +instance Property "S3BucketName" AccessLoggingPolicyProperty where + type PropertyType "S3BucketName" AccessLoggingPolicyProperty = Value Prelude.Text + set newValue AccessLoggingPolicyProperty {..} + = AccessLoggingPolicyProperty {s3BucketName = newValue, ..} +instance Property "S3BucketPrefix" AccessLoggingPolicyProperty where + type PropertyType "S3BucketPrefix" AccessLoggingPolicyProperty = Value Prelude.Text + set newValue AccessLoggingPolicyProperty {..} + = AccessLoggingPolicyProperty + {s3BucketPrefix = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AccessLoggingPolicyProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AccessLoggingPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AccessLoggingPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.AccessLoggingPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AccessLoggingPolicyProperty :: Prelude.Type +instance ToResourceProperties AccessLoggingPolicyProperty +instance Prelude.Eq AccessLoggingPolicyProperty +instance Prelude.Show AccessLoggingPolicyProperty +instance JSON.ToJSON AccessLoggingPolicyProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AppCookieStickinessPolicyProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AppCookieStickinessPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AppCookieStickinessPolicyProperty.hs @@ -0,0 +1,43 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.AppCookieStickinessPolicyProperty ( + AppCookieStickinessPolicyProperty(..), + mkAppCookieStickinessPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AppCookieStickinessPolicyProperty + = -- | See: + AppCookieStickinessPolicyProperty {haddock_workaround_ :: (), + -- | See: + cookieName :: (Value Prelude.Text), + -- | See: + policyName :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkAppCookieStickinessPolicyProperty :: + Value Prelude.Text + -> Value Prelude.Text -> AppCookieStickinessPolicyProperty +mkAppCookieStickinessPolicyProperty cookieName policyName + = AppCookieStickinessPolicyProperty + {haddock_workaround_ = (), cookieName = cookieName, + policyName = policyName} +instance ToResourceProperties AppCookieStickinessPolicyProperty where + toResourceProperties AppCookieStickinessPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.AppCookieStickinessPolicy", + supportsTags = Prelude.False, + properties = ["CookieName" JSON..= cookieName, + "PolicyName" JSON..= policyName]} +instance JSON.ToJSON AppCookieStickinessPolicyProperty where + toJSON AppCookieStickinessPolicyProperty {..} + = JSON.object + ["CookieName" JSON..= cookieName, "PolicyName" JSON..= policyName] +instance Property "CookieName" AppCookieStickinessPolicyProperty where + type PropertyType "CookieName" AppCookieStickinessPolicyProperty = Value Prelude.Text + set newValue AppCookieStickinessPolicyProperty {..} + = AppCookieStickinessPolicyProperty {cookieName = newValue, ..} +instance Property "PolicyName" AppCookieStickinessPolicyProperty where + type PropertyType "PolicyName" AppCookieStickinessPolicyProperty = Value Prelude.Text + set newValue AppCookieStickinessPolicyProperty {..} + = AppCookieStickinessPolicyProperty {policyName = newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AppCookieStickinessPolicyProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AppCookieStickinessPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/AppCookieStickinessPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.AppCookieStickinessPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AppCookieStickinessPolicyProperty :: Prelude.Type +instance ToResourceProperties AppCookieStickinessPolicyProperty +instance Prelude.Eq AppCookieStickinessPolicyProperty +instance Prelude.Show AppCookieStickinessPolicyProperty +instance JSON.ToJSON AppCookieStickinessPolicyProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionDrainingPolicyProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionDrainingPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionDrainingPolicyProperty.hs @@ -0,0 +1,48 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionDrainingPolicyProperty ( + ConnectionDrainingPolicyProperty(..), + mkConnectionDrainingPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ConnectionDrainingPolicyProperty + = -- | See: + ConnectionDrainingPolicyProperty {haddock_workaround_ :: (), + -- | See: + enabled :: (Value Prelude.Bool), + -- | See: + timeout :: (Prelude.Maybe (Value Prelude.Integer))} + deriving stock (Prelude.Eq, Prelude.Show) +mkConnectionDrainingPolicyProperty :: + Value Prelude.Bool -> ConnectionDrainingPolicyProperty +mkConnectionDrainingPolicyProperty enabled + = ConnectionDrainingPolicyProperty + {haddock_workaround_ = (), enabled = enabled, + timeout = Prelude.Nothing} +instance ToResourceProperties ConnectionDrainingPolicyProperty where + toResourceProperties ConnectionDrainingPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.ConnectionDrainingPolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Enabled" JSON..= enabled] + (Prelude.catMaybes [(JSON..=) "Timeout" Prelude.<$> timeout]))} +instance JSON.ToJSON ConnectionDrainingPolicyProperty where + toJSON ConnectionDrainingPolicyProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Enabled" JSON..= enabled] + (Prelude.catMaybes [(JSON..=) "Timeout" Prelude.<$> timeout]))) +instance Property "Enabled" ConnectionDrainingPolicyProperty where + type PropertyType "Enabled" ConnectionDrainingPolicyProperty = Value Prelude.Bool + set newValue ConnectionDrainingPolicyProperty {..} + = ConnectionDrainingPolicyProperty {enabled = newValue, ..} +instance Property "Timeout" ConnectionDrainingPolicyProperty where + type PropertyType "Timeout" ConnectionDrainingPolicyProperty = Value Prelude.Integer + set newValue ConnectionDrainingPolicyProperty {..} + = ConnectionDrainingPolicyProperty + {timeout = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionDrainingPolicyProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionDrainingPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionDrainingPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionDrainingPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ConnectionDrainingPolicyProperty :: Prelude.Type +instance ToResourceProperties ConnectionDrainingPolicyProperty +instance Prelude.Eq ConnectionDrainingPolicyProperty +instance Prelude.Show ConnectionDrainingPolicyProperty +instance JSON.ToJSON ConnectionDrainingPolicyProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionSettingsProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionSettingsProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionSettingsProperty.hs @@ -0,0 +1,32 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionSettingsProperty ( + ConnectionSettingsProperty(..), mkConnectionSettingsProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ConnectionSettingsProperty + = -- | See: + ConnectionSettingsProperty {haddock_workaround_ :: (), + -- | See: + idleTimeout :: (Value Prelude.Integer)} + deriving stock (Prelude.Eq, Prelude.Show) +mkConnectionSettingsProperty :: + Value Prelude.Integer -> ConnectionSettingsProperty +mkConnectionSettingsProperty idleTimeout + = ConnectionSettingsProperty + {haddock_workaround_ = (), idleTimeout = idleTimeout} +instance ToResourceProperties ConnectionSettingsProperty where + toResourceProperties ConnectionSettingsProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.ConnectionSettings", + supportsTags = Prelude.False, + properties = ["IdleTimeout" JSON..= idleTimeout]} +instance JSON.ToJSON ConnectionSettingsProperty where + toJSON ConnectionSettingsProperty {..} + = JSON.object ["IdleTimeout" JSON..= idleTimeout] +instance Property "IdleTimeout" ConnectionSettingsProperty where + type PropertyType "IdleTimeout" ConnectionSettingsProperty = Value Prelude.Integer + set newValue ConnectionSettingsProperty {..} + = ConnectionSettingsProperty {idleTimeout = newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionSettingsProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionSettingsProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ConnectionSettingsProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionSettingsProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ConnectionSettingsProperty :: Prelude.Type +instance ToResourceProperties ConnectionSettingsProperty +instance Prelude.Eq ConnectionSettingsProperty +instance Prelude.Show ConnectionSettingsProperty +instance JSON.ToJSON ConnectionSettingsProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/HealthCheckProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/HealthCheckProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/HealthCheckProperty.hs @@ -0,0 +1,73 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.HealthCheckProperty ( + HealthCheckProperty(..), mkHealthCheckProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data HealthCheckProperty + = -- | See: + HealthCheckProperty {haddock_workaround_ :: (), + -- | See: + healthyThreshold :: (Value Prelude.Text), + -- | See: + interval :: (Value Prelude.Text), + -- | See: + target :: (Value Prelude.Text), + -- | See: + timeout :: (Value Prelude.Text), + -- | See: + unhealthyThreshold :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkHealthCheckProperty :: + Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text + -> Value Prelude.Text -> Value Prelude.Text -> HealthCheckProperty +mkHealthCheckProperty + healthyThreshold + interval + target + timeout + unhealthyThreshold + = HealthCheckProperty + {haddock_workaround_ = (), healthyThreshold = healthyThreshold, + interval = interval, target = target, timeout = timeout, + unhealthyThreshold = unhealthyThreshold} +instance ToResourceProperties HealthCheckProperty where + toResourceProperties HealthCheckProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.HealthCheck", + supportsTags = Prelude.False, + properties = ["HealthyThreshold" JSON..= healthyThreshold, + "Interval" JSON..= interval, "Target" JSON..= target, + "Timeout" JSON..= timeout, + "UnhealthyThreshold" JSON..= unhealthyThreshold]} +instance JSON.ToJSON HealthCheckProperty where + toJSON HealthCheckProperty {..} + = JSON.object + ["HealthyThreshold" JSON..= healthyThreshold, + "Interval" JSON..= interval, "Target" JSON..= target, + "Timeout" JSON..= timeout, + "UnhealthyThreshold" JSON..= unhealthyThreshold] +instance Property "HealthyThreshold" HealthCheckProperty where + type PropertyType "HealthyThreshold" HealthCheckProperty = Value Prelude.Text + set newValue HealthCheckProperty {..} + = HealthCheckProperty {healthyThreshold = newValue, ..} +instance Property "Interval" HealthCheckProperty where + type PropertyType "Interval" HealthCheckProperty = Value Prelude.Text + set newValue HealthCheckProperty {..} + = HealthCheckProperty {interval = newValue, ..} +instance Property "Target" HealthCheckProperty where + type PropertyType "Target" HealthCheckProperty = Value Prelude.Text + set newValue HealthCheckProperty {..} + = HealthCheckProperty {target = newValue, ..} +instance Property "Timeout" HealthCheckProperty where + type PropertyType "Timeout" HealthCheckProperty = Value Prelude.Text + set newValue HealthCheckProperty {..} + = HealthCheckProperty {timeout = newValue, ..} +instance Property "UnhealthyThreshold" HealthCheckProperty where + type PropertyType "UnhealthyThreshold" HealthCheckProperty = Value Prelude.Text + set newValue HealthCheckProperty {..} + = HealthCheckProperty {unhealthyThreshold = newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/HealthCheckProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/HealthCheckProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/HealthCheckProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.HealthCheckProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data HealthCheckProperty :: Prelude.Type +instance ToResourceProperties HealthCheckProperty +instance Prelude.Eq HealthCheckProperty +instance Prelude.Show HealthCheckProperty +instance JSON.ToJSON HealthCheckProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/LBCookieStickinessPolicyProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/LBCookieStickinessPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/LBCookieStickinessPolicyProperty.hs @@ -0,0 +1,52 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.LBCookieStickinessPolicyProperty ( + LBCookieStickinessPolicyProperty(..), + mkLBCookieStickinessPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LBCookieStickinessPolicyProperty + = -- | See: + LBCookieStickinessPolicyProperty {haddock_workaround_ :: (), + -- | See: + cookieExpirationPeriod :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + policyName :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLBCookieStickinessPolicyProperty :: + LBCookieStickinessPolicyProperty +mkLBCookieStickinessPolicyProperty + = LBCookieStickinessPolicyProperty + {haddock_workaround_ = (), + cookieExpirationPeriod = Prelude.Nothing, + policyName = Prelude.Nothing} +instance ToResourceProperties LBCookieStickinessPolicyProperty where + toResourceProperties LBCookieStickinessPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.LBCookieStickinessPolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CookieExpirationPeriod" + Prelude.<$> cookieExpirationPeriod, + (JSON..=) "PolicyName" Prelude.<$> policyName])} +instance JSON.ToJSON LBCookieStickinessPolicyProperty where + toJSON LBCookieStickinessPolicyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CookieExpirationPeriod" + Prelude.<$> cookieExpirationPeriod, + (JSON..=) "PolicyName" Prelude.<$> policyName])) +instance Property "CookieExpirationPeriod" LBCookieStickinessPolicyProperty where + type PropertyType "CookieExpirationPeriod" LBCookieStickinessPolicyProperty = Value Prelude.Text + set newValue LBCookieStickinessPolicyProperty {..} + = LBCookieStickinessPolicyProperty + {cookieExpirationPeriod = Prelude.pure newValue, ..} +instance Property "PolicyName" LBCookieStickinessPolicyProperty where + type PropertyType "PolicyName" LBCookieStickinessPolicyProperty = Value Prelude.Text + set newValue LBCookieStickinessPolicyProperty {..} + = LBCookieStickinessPolicyProperty + {policyName = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/LBCookieStickinessPolicyProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/LBCookieStickinessPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/LBCookieStickinessPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.LBCookieStickinessPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LBCookieStickinessPolicyProperty :: Prelude.Type +instance ToResourceProperties LBCookieStickinessPolicyProperty +instance Prelude.Eq LBCookieStickinessPolicyProperty +instance Prelude.Show LBCookieStickinessPolicyProperty +instance JSON.ToJSON LBCookieStickinessPolicyProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ListenersProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ListenersProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ListenersProperty.hs @@ -0,0 +1,83 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.ListenersProperty ( + ListenersProperty(..), mkListenersProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ListenersProperty + = -- | See: + ListenersProperty {haddock_workaround_ :: (), + -- | See: + instancePort :: (Value Prelude.Text), + -- | See: + instanceProtocol :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + loadBalancerPort :: (Value Prelude.Text), + -- | See: + policyNames :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + protocol :: (Value Prelude.Text), + -- | See: + sSLCertificateId :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkListenersProperty :: + Value Prelude.Text + -> Value Prelude.Text -> Value Prelude.Text -> ListenersProperty +mkListenersProperty instancePort loadBalancerPort protocol + = ListenersProperty + {haddock_workaround_ = (), instancePort = instancePort, + loadBalancerPort = loadBalancerPort, protocol = protocol, + instanceProtocol = Prelude.Nothing, policyNames = Prelude.Nothing, + sSLCertificateId = Prelude.Nothing} +instance ToResourceProperties ListenersProperty where + toResourceProperties ListenersProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.Listeners", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["InstancePort" JSON..= instancePort, + "LoadBalancerPort" JSON..= loadBalancerPort, + "Protocol" JSON..= protocol] + (Prelude.catMaybes + [(JSON..=) "InstanceProtocol" Prelude.<$> instanceProtocol, + (JSON..=) "PolicyNames" Prelude.<$> policyNames, + (JSON..=) "SSLCertificateId" Prelude.<$> sSLCertificateId]))} +instance JSON.ToJSON ListenersProperty where + toJSON ListenersProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["InstancePort" JSON..= instancePort, + "LoadBalancerPort" JSON..= loadBalancerPort, + "Protocol" JSON..= protocol] + (Prelude.catMaybes + [(JSON..=) "InstanceProtocol" Prelude.<$> instanceProtocol, + (JSON..=) "PolicyNames" Prelude.<$> policyNames, + (JSON..=) "SSLCertificateId" Prelude.<$> sSLCertificateId]))) +instance Property "InstancePort" ListenersProperty where + type PropertyType "InstancePort" ListenersProperty = Value Prelude.Text + set newValue ListenersProperty {..} + = ListenersProperty {instancePort = newValue, ..} +instance Property "InstanceProtocol" ListenersProperty where + type PropertyType "InstanceProtocol" ListenersProperty = Value Prelude.Text + set newValue ListenersProperty {..} + = ListenersProperty {instanceProtocol = Prelude.pure newValue, ..} +instance Property "LoadBalancerPort" ListenersProperty where + type PropertyType "LoadBalancerPort" ListenersProperty = Value Prelude.Text + set newValue ListenersProperty {..} + = ListenersProperty {loadBalancerPort = newValue, ..} +instance Property "PolicyNames" ListenersProperty where + type PropertyType "PolicyNames" ListenersProperty = ValueList Prelude.Text + set newValue ListenersProperty {..} + = ListenersProperty {policyNames = Prelude.pure newValue, ..} +instance Property "Protocol" ListenersProperty where + type PropertyType "Protocol" ListenersProperty = Value Prelude.Text + set newValue ListenersProperty {..} + = ListenersProperty {protocol = newValue, ..} +instance Property "SSLCertificateId" ListenersProperty where + type PropertyType "SSLCertificateId" ListenersProperty = Value Prelude.Text + set newValue ListenersProperty {..} + = ListenersProperty {sSLCertificateId = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ListenersProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ListenersProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/ListenersProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.ListenersProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ListenersProperty :: Prelude.Type +instance ToResourceProperties ListenersProperty +instance Prelude.Eq ListenersProperty +instance Prelude.Show ListenersProperty +instance JSON.ToJSON ListenersProperty diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/PoliciesProperty.hs b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/PoliciesProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/PoliciesProperty.hs @@ -0,0 +1,73 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.PoliciesProperty ( + PoliciesProperty(..), mkPoliciesProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data PoliciesProperty + = -- | See: + PoliciesProperty {haddock_workaround_ :: (), + -- | See: + attributes :: JSON.Object, + -- | See: + instancePorts :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + loadBalancerPorts :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + policyName :: (Value Prelude.Text), + -- | See: + policyType :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkPoliciesProperty :: + JSON.Object + -> Value Prelude.Text -> Value Prelude.Text -> PoliciesProperty +mkPoliciesProperty attributes policyName policyType + = PoliciesProperty + {haddock_workaround_ = (), attributes = attributes, + policyName = policyName, policyType = policyType, + instancePorts = Prelude.Nothing, + loadBalancerPorts = Prelude.Nothing} +instance ToResourceProperties PoliciesProperty where + toResourceProperties PoliciesProperty {..} + = ResourceProperties + {awsType = "AWS::ElasticLoadBalancing::LoadBalancer.Policies", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Attributes" JSON..= attributes, "PolicyName" JSON..= policyName, + "PolicyType" JSON..= policyType] + (Prelude.catMaybes + [(JSON..=) "InstancePorts" Prelude.<$> instancePorts, + (JSON..=) "LoadBalancerPorts" Prelude.<$> loadBalancerPorts]))} +instance JSON.ToJSON PoliciesProperty where + toJSON PoliciesProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Attributes" JSON..= attributes, "PolicyName" JSON..= policyName, + "PolicyType" JSON..= policyType] + (Prelude.catMaybes + [(JSON..=) "InstancePorts" Prelude.<$> instancePorts, + (JSON..=) "LoadBalancerPorts" Prelude.<$> loadBalancerPorts]))) +instance Property "Attributes" PoliciesProperty where + type PropertyType "Attributes" PoliciesProperty = JSON.Object + set newValue PoliciesProperty {..} + = PoliciesProperty {attributes = newValue, ..} +instance Property "InstancePorts" PoliciesProperty where + type PropertyType "InstancePorts" PoliciesProperty = ValueList Prelude.Text + set newValue PoliciesProperty {..} + = PoliciesProperty {instancePorts = Prelude.pure newValue, ..} +instance Property "LoadBalancerPorts" PoliciesProperty where + type PropertyType "LoadBalancerPorts" PoliciesProperty = ValueList Prelude.Text + set newValue PoliciesProperty {..} + = PoliciesProperty {loadBalancerPorts = Prelude.pure newValue, ..} +instance Property "PolicyName" PoliciesProperty where + type PropertyType "PolicyName" PoliciesProperty = Value Prelude.Text + set newValue PoliciesProperty {..} + = PoliciesProperty {policyName = newValue, ..} +instance Property "PolicyType" PoliciesProperty where + type PropertyType "PolicyType" PoliciesProperty = Value Prelude.Text + set newValue PoliciesProperty {..} + = PoliciesProperty {policyType = newValue, ..} diff --git a/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/PoliciesProperty.hs-boot b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/PoliciesProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/ElasticLoadBalancing/LoadBalancer/PoliciesProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.ElasticLoadBalancing.LoadBalancer.PoliciesProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data PoliciesProperty :: Prelude.Type +instance ToResourceProperties PoliciesProperty +instance Prelude.Eq PoliciesProperty +instance Prelude.Show PoliciesProperty +instance JSON.ToJSON PoliciesProperty diff --git a/stratosphere-elasticloadbalancing.cabal b/stratosphere-elasticloadbalancing.cabal new file mode 100644 --- /dev/null +++ b/stratosphere-elasticloadbalancing.cabal @@ -0,0 +1,81 @@ +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-elasticloadbalancing +version: 1.0.0 +synopsis: Stratosphere integration for AWS ElasticLoadBalancing. +description: Integration into stratosphere to generate resources and properties for AWS ElasticLoadBalancing +category: AWS, Cloud, ElasticLoadBalancing +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.ElasticLoadBalancing.LoadBalancer + Stratosphere.ElasticLoadBalancing.LoadBalancer.AccessLoggingPolicyProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.AppCookieStickinessPolicyProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionDrainingPolicyProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.ConnectionSettingsProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.HealthCheckProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.LBCookieStickinessPolicyProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.ListenersProperty + Stratosphere.ElasticLoadBalancing.LoadBalancer.PoliciesProperty + other-modules: + Paths_stratosphere_elasticloadbalancing + 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