{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.RedshiftServerLess.CreateWorkgroup
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates an workgroup in Amazon Redshift Serverless.
module Amazonka.RedshiftServerLess.CreateWorkgroup
  ( -- * Creating a Request
    CreateWorkgroup (..),
    newCreateWorkgroup,

    -- * Request Lenses
    createWorkgroup_baseCapacity,
    createWorkgroup_configParameters,
    createWorkgroup_enhancedVpcRouting,
    createWorkgroup_port,
    createWorkgroup_publiclyAccessible,
    createWorkgroup_securityGroupIds,
    createWorkgroup_subnetIds,
    createWorkgroup_tags,
    createWorkgroup_namespaceName,
    createWorkgroup_workgroupName,

    -- * Destructuring the Response
    CreateWorkgroupResponse (..),
    newCreateWorkgroupResponse,

    -- * Response Lenses
    createWorkgroupResponse_workgroup,
    createWorkgroupResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.RedshiftServerLess.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateWorkgroup' smart constructor.
data CreateWorkgroup = CreateWorkgroup'
  { -- | The base data warehouse capacity of the workgroup in Redshift Processing
    -- Units (RPUs).
    CreateWorkgroup -> Maybe Int
baseCapacity :: Prelude.Maybe Prelude.Int,
    -- | An array of parameters to set for more control over a serverless
    -- database. The options are @datestyle@, @enable_user_activity_logging@,
    -- @query_group@, @search_path@, and @max_query_execution_time@.
    CreateWorkgroup -> Maybe [ConfigParameter]
configParameters :: Prelude.Maybe [ConfigParameter],
    -- | The value that specifies whether to turn on enhanced virtual private
    -- cloud (VPC) routing, which forces Amazon Redshift Serverless to route
    -- traffic through your VPC instead of over the internet.
    CreateWorkgroup -> Maybe Bool
enhancedVpcRouting :: Prelude.Maybe Prelude.Bool,
    -- | The custom port to use when connecting to a workgroup. Valid port ranges
    -- are 5431-5455 and 8191-8215. The default is 5439.
    CreateWorkgroup -> Maybe Int
port :: Prelude.Maybe Prelude.Int,
    -- | A value that specifies whether the workgroup can be accessed from a
    -- public network.
    CreateWorkgroup -> Maybe Bool
publiclyAccessible :: Prelude.Maybe Prelude.Bool,
    -- | An array of security group IDs to associate with the workgroup.
    CreateWorkgroup -> Maybe [Text]
securityGroupIds :: Prelude.Maybe [Prelude.Text],
    -- | An array of VPC subnet IDs to associate with the workgroup.
    CreateWorkgroup -> Maybe [Text]
subnetIds :: Prelude.Maybe [Prelude.Text],
    -- | A array of tag instances.
    CreateWorkgroup -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the namespace to associate with the workgroup.
    CreateWorkgroup -> Text
namespaceName :: Prelude.Text,
    -- | The name of the created workgroup.
    CreateWorkgroup -> Text
workgroupName :: Prelude.Text
  }
  deriving (CreateWorkgroup -> CreateWorkgroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateWorkgroup -> CreateWorkgroup -> Bool
$c/= :: CreateWorkgroup -> CreateWorkgroup -> Bool
== :: CreateWorkgroup -> CreateWorkgroup -> Bool
$c== :: CreateWorkgroup -> CreateWorkgroup -> Bool
Prelude.Eq, ReadPrec [CreateWorkgroup]
ReadPrec CreateWorkgroup
Int -> ReadS CreateWorkgroup
ReadS [CreateWorkgroup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateWorkgroup]
$creadListPrec :: ReadPrec [CreateWorkgroup]
readPrec :: ReadPrec CreateWorkgroup
$creadPrec :: ReadPrec CreateWorkgroup
readList :: ReadS [CreateWorkgroup]
$creadList :: ReadS [CreateWorkgroup]
readsPrec :: Int -> ReadS CreateWorkgroup
$creadsPrec :: Int -> ReadS CreateWorkgroup
Prelude.Read, Int -> CreateWorkgroup -> ShowS
[CreateWorkgroup] -> ShowS
CreateWorkgroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateWorkgroup] -> ShowS
$cshowList :: [CreateWorkgroup] -> ShowS
show :: CreateWorkgroup -> String
$cshow :: CreateWorkgroup -> String
showsPrec :: Int -> CreateWorkgroup -> ShowS
$cshowsPrec :: Int -> CreateWorkgroup -> ShowS
Prelude.Show, forall x. Rep CreateWorkgroup x -> CreateWorkgroup
forall x. CreateWorkgroup -> Rep CreateWorkgroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateWorkgroup x -> CreateWorkgroup
$cfrom :: forall x. CreateWorkgroup -> Rep CreateWorkgroup x
Prelude.Generic)

-- |
-- Create a value of 'CreateWorkgroup' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'baseCapacity', 'createWorkgroup_baseCapacity' - The base data warehouse capacity of the workgroup in Redshift Processing
-- Units (RPUs).
--
-- 'configParameters', 'createWorkgroup_configParameters' - An array of parameters to set for more control over a serverless
-- database. The options are @datestyle@, @enable_user_activity_logging@,
-- @query_group@, @search_path@, and @max_query_execution_time@.
--
-- 'enhancedVpcRouting', 'createWorkgroup_enhancedVpcRouting' - The value that specifies whether to turn on enhanced virtual private
-- cloud (VPC) routing, which forces Amazon Redshift Serverless to route
-- traffic through your VPC instead of over the internet.
--
-- 'port', 'createWorkgroup_port' - The custom port to use when connecting to a workgroup. Valid port ranges
-- are 5431-5455 and 8191-8215. The default is 5439.
--
-- 'publiclyAccessible', 'createWorkgroup_publiclyAccessible' - A value that specifies whether the workgroup can be accessed from a
-- public network.
--
-- 'securityGroupIds', 'createWorkgroup_securityGroupIds' - An array of security group IDs to associate with the workgroup.
--
-- 'subnetIds', 'createWorkgroup_subnetIds' - An array of VPC subnet IDs to associate with the workgroup.
--
-- 'tags', 'createWorkgroup_tags' - A array of tag instances.
--
-- 'namespaceName', 'createWorkgroup_namespaceName' - The name of the namespace to associate with the workgroup.
--
-- 'workgroupName', 'createWorkgroup_workgroupName' - The name of the created workgroup.
newCreateWorkgroup ::
  -- | 'namespaceName'
  Prelude.Text ->
  -- | 'workgroupName'
  Prelude.Text ->
  CreateWorkgroup
newCreateWorkgroup :: Text -> Text -> CreateWorkgroup
newCreateWorkgroup Text
pNamespaceName_ Text
pWorkgroupName_ =
  CreateWorkgroup'
    { $sel:baseCapacity:CreateWorkgroup' :: Maybe Int
baseCapacity = forall a. Maybe a
Prelude.Nothing,
      $sel:configParameters:CreateWorkgroup' :: Maybe [ConfigParameter]
configParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:enhancedVpcRouting:CreateWorkgroup' :: Maybe Bool
enhancedVpcRouting = forall a. Maybe a
Prelude.Nothing,
      $sel:port:CreateWorkgroup' :: Maybe Int
port = forall a. Maybe a
Prelude.Nothing,
      $sel:publiclyAccessible:CreateWorkgroup' :: Maybe Bool
publiclyAccessible = forall a. Maybe a
Prelude.Nothing,
      $sel:securityGroupIds:CreateWorkgroup' :: Maybe [Text]
securityGroupIds = forall a. Maybe a
Prelude.Nothing,
      $sel:subnetIds:CreateWorkgroup' :: Maybe [Text]
subnetIds = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateWorkgroup' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:namespaceName:CreateWorkgroup' :: Text
namespaceName = Text
pNamespaceName_,
      $sel:workgroupName:CreateWorkgroup' :: Text
workgroupName = Text
pWorkgroupName_
    }

-- | The base data warehouse capacity of the workgroup in Redshift Processing
-- Units (RPUs).
createWorkgroup_baseCapacity :: Lens.Lens' CreateWorkgroup (Prelude.Maybe Prelude.Int)
createWorkgroup_baseCapacity :: Lens' CreateWorkgroup (Maybe Int)
createWorkgroup_baseCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe Int
baseCapacity :: Maybe Int
$sel:baseCapacity:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
baseCapacity} -> Maybe Int
baseCapacity) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe Int
a -> CreateWorkgroup
s {$sel:baseCapacity:CreateWorkgroup' :: Maybe Int
baseCapacity = Maybe Int
a} :: CreateWorkgroup)

-- | An array of parameters to set for more control over a serverless
-- database. The options are @datestyle@, @enable_user_activity_logging@,
-- @query_group@, @search_path@, and @max_query_execution_time@.
createWorkgroup_configParameters :: Lens.Lens' CreateWorkgroup (Prelude.Maybe [ConfigParameter])
createWorkgroup_configParameters :: Lens' CreateWorkgroup (Maybe [ConfigParameter])
createWorkgroup_configParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe [ConfigParameter]
configParameters :: Maybe [ConfigParameter]
$sel:configParameters:CreateWorkgroup' :: CreateWorkgroup -> Maybe [ConfigParameter]
configParameters} -> Maybe [ConfigParameter]
configParameters) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe [ConfigParameter]
a -> CreateWorkgroup
s {$sel:configParameters:CreateWorkgroup' :: Maybe [ConfigParameter]
configParameters = Maybe [ConfigParameter]
a} :: CreateWorkgroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The value that specifies whether to turn on enhanced virtual private
-- cloud (VPC) routing, which forces Amazon Redshift Serverless to route
-- traffic through your VPC instead of over the internet.
createWorkgroup_enhancedVpcRouting :: Lens.Lens' CreateWorkgroup (Prelude.Maybe Prelude.Bool)
createWorkgroup_enhancedVpcRouting :: Lens' CreateWorkgroup (Maybe Bool)
createWorkgroup_enhancedVpcRouting = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe Bool
enhancedVpcRouting :: Maybe Bool
$sel:enhancedVpcRouting:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
enhancedVpcRouting} -> Maybe Bool
enhancedVpcRouting) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe Bool
a -> CreateWorkgroup
s {$sel:enhancedVpcRouting:CreateWorkgroup' :: Maybe Bool
enhancedVpcRouting = Maybe Bool
a} :: CreateWorkgroup)

-- | The custom port to use when connecting to a workgroup. Valid port ranges
-- are 5431-5455 and 8191-8215. The default is 5439.
createWorkgroup_port :: Lens.Lens' CreateWorkgroup (Prelude.Maybe Prelude.Int)
createWorkgroup_port :: Lens' CreateWorkgroup (Maybe Int)
createWorkgroup_port = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe Int
port :: Maybe Int
$sel:port:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
port} -> Maybe Int
port) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe Int
a -> CreateWorkgroup
s {$sel:port:CreateWorkgroup' :: Maybe Int
port = Maybe Int
a} :: CreateWorkgroup)

-- | A value that specifies whether the workgroup can be accessed from a
-- public network.
createWorkgroup_publiclyAccessible :: Lens.Lens' CreateWorkgroup (Prelude.Maybe Prelude.Bool)
createWorkgroup_publiclyAccessible :: Lens' CreateWorkgroup (Maybe Bool)
createWorkgroup_publiclyAccessible = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe Bool
publiclyAccessible :: Maybe Bool
$sel:publiclyAccessible:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
publiclyAccessible} -> Maybe Bool
publiclyAccessible) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe Bool
a -> CreateWorkgroup
s {$sel:publiclyAccessible:CreateWorkgroup' :: Maybe Bool
publiclyAccessible = Maybe Bool
a} :: CreateWorkgroup)

-- | An array of security group IDs to associate with the workgroup.
createWorkgroup_securityGroupIds :: Lens.Lens' CreateWorkgroup (Prelude.Maybe [Prelude.Text])
createWorkgroup_securityGroupIds :: Lens' CreateWorkgroup (Maybe [Text])
createWorkgroup_securityGroupIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe [Text]
securityGroupIds :: Maybe [Text]
$sel:securityGroupIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
securityGroupIds} -> Maybe [Text]
securityGroupIds) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe [Text]
a -> CreateWorkgroup
s {$sel:securityGroupIds:CreateWorkgroup' :: Maybe [Text]
securityGroupIds = Maybe [Text]
a} :: CreateWorkgroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | An array of VPC subnet IDs to associate with the workgroup.
createWorkgroup_subnetIds :: Lens.Lens' CreateWorkgroup (Prelude.Maybe [Prelude.Text])
createWorkgroup_subnetIds :: Lens' CreateWorkgroup (Maybe [Text])
createWorkgroup_subnetIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe [Text]
subnetIds :: Maybe [Text]
$sel:subnetIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
subnetIds} -> Maybe [Text]
subnetIds) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe [Text]
a -> CreateWorkgroup
s {$sel:subnetIds:CreateWorkgroup' :: Maybe [Text]
subnetIds = Maybe [Text]
a} :: CreateWorkgroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A array of tag instances.
createWorkgroup_tags :: Lens.Lens' CreateWorkgroup (Prelude.Maybe [Tag])
createWorkgroup_tags :: Lens' CreateWorkgroup (Maybe [Tag])
createWorkgroup_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Maybe [Tag]
a -> CreateWorkgroup
s {$sel:tags:CreateWorkgroup' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateWorkgroup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the namespace to associate with the workgroup.
createWorkgroup_namespaceName :: Lens.Lens' CreateWorkgroup Prelude.Text
createWorkgroup_namespaceName :: Lens' CreateWorkgroup Text
createWorkgroup_namespaceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Text
namespaceName :: Text
$sel:namespaceName:CreateWorkgroup' :: CreateWorkgroup -> Text
namespaceName} -> Text
namespaceName) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Text
a -> CreateWorkgroup
s {$sel:namespaceName:CreateWorkgroup' :: Text
namespaceName = Text
a} :: CreateWorkgroup)

-- | The name of the created workgroup.
createWorkgroup_workgroupName :: Lens.Lens' CreateWorkgroup Prelude.Text
createWorkgroup_workgroupName :: Lens' CreateWorkgroup Text
createWorkgroup_workgroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroup' {Text
workgroupName :: Text
$sel:workgroupName:CreateWorkgroup' :: CreateWorkgroup -> Text
workgroupName} -> Text
workgroupName) (\s :: CreateWorkgroup
s@CreateWorkgroup' {} Text
a -> CreateWorkgroup
s {$sel:workgroupName:CreateWorkgroup' :: Text
workgroupName = Text
a} :: CreateWorkgroup)

instance Core.AWSRequest CreateWorkgroup where
  type
    AWSResponse CreateWorkgroup =
      CreateWorkgroupResponse
  request :: (Service -> Service) -> CreateWorkgroup -> Request CreateWorkgroup
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateWorkgroup
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateWorkgroup)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Workgroup -> Int -> CreateWorkgroupResponse
CreateWorkgroupResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"workgroup")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateWorkgroup where
  hashWithSalt :: Int -> CreateWorkgroup -> Int
hashWithSalt Int
_salt CreateWorkgroup' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [ConfigParameter]
Maybe [Tag]
Text
workgroupName :: Text
namespaceName :: Text
tags :: Maybe [Tag]
subnetIds :: Maybe [Text]
securityGroupIds :: Maybe [Text]
publiclyAccessible :: Maybe Bool
port :: Maybe Int
enhancedVpcRouting :: Maybe Bool
configParameters :: Maybe [ConfigParameter]
baseCapacity :: Maybe Int
$sel:workgroupName:CreateWorkgroup' :: CreateWorkgroup -> Text
$sel:namespaceName:CreateWorkgroup' :: CreateWorkgroup -> Text
$sel:tags:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Tag]
$sel:subnetIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
$sel:securityGroupIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
$sel:publiclyAccessible:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
$sel:port:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
$sel:enhancedVpcRouting:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
$sel:configParameters:CreateWorkgroup' :: CreateWorkgroup -> Maybe [ConfigParameter]
$sel:baseCapacity:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
baseCapacity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ConfigParameter]
configParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
enhancedVpcRouting
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
port
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
publiclyAccessible
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
securityGroupIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
subnetIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
namespaceName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
workgroupName

instance Prelude.NFData CreateWorkgroup where
  rnf :: CreateWorkgroup -> ()
rnf CreateWorkgroup' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [ConfigParameter]
Maybe [Tag]
Text
workgroupName :: Text
namespaceName :: Text
tags :: Maybe [Tag]
subnetIds :: Maybe [Text]
securityGroupIds :: Maybe [Text]
publiclyAccessible :: Maybe Bool
port :: Maybe Int
enhancedVpcRouting :: Maybe Bool
configParameters :: Maybe [ConfigParameter]
baseCapacity :: Maybe Int
$sel:workgroupName:CreateWorkgroup' :: CreateWorkgroup -> Text
$sel:namespaceName:CreateWorkgroup' :: CreateWorkgroup -> Text
$sel:tags:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Tag]
$sel:subnetIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
$sel:securityGroupIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
$sel:publiclyAccessible:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
$sel:port:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
$sel:enhancedVpcRouting:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
$sel:configParameters:CreateWorkgroup' :: CreateWorkgroup -> Maybe [ConfigParameter]
$sel:baseCapacity:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
baseCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ConfigParameter]
configParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
enhancedVpcRouting
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
port
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
publiclyAccessible
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
securityGroupIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
subnetIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
namespaceName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
workgroupName

instance Data.ToHeaders CreateWorkgroup where
  toHeaders :: CreateWorkgroup -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"RedshiftServerless.CreateWorkgroup" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateWorkgroup where
  toJSON :: CreateWorkgroup -> Value
toJSON CreateWorkgroup' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [ConfigParameter]
Maybe [Tag]
Text
workgroupName :: Text
namespaceName :: Text
tags :: Maybe [Tag]
subnetIds :: Maybe [Text]
securityGroupIds :: Maybe [Text]
publiclyAccessible :: Maybe Bool
port :: Maybe Int
enhancedVpcRouting :: Maybe Bool
configParameters :: Maybe [ConfigParameter]
baseCapacity :: Maybe Int
$sel:workgroupName:CreateWorkgroup' :: CreateWorkgroup -> Text
$sel:namespaceName:CreateWorkgroup' :: CreateWorkgroup -> Text
$sel:tags:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Tag]
$sel:subnetIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
$sel:securityGroupIds:CreateWorkgroup' :: CreateWorkgroup -> Maybe [Text]
$sel:publiclyAccessible:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
$sel:port:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
$sel:enhancedVpcRouting:CreateWorkgroup' :: CreateWorkgroup -> Maybe Bool
$sel:configParameters:CreateWorkgroup' :: CreateWorkgroup -> Maybe [ConfigParameter]
$sel:baseCapacity:CreateWorkgroup' :: CreateWorkgroup -> Maybe Int
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"baseCapacity" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
baseCapacity,
            (Key
"configParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ConfigParameter]
configParameters,
            (Key
"enhancedVpcRouting" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
enhancedVpcRouting,
            (Key
"port" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
port,
            (Key
"publiclyAccessible" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
publiclyAccessible,
            (Key
"securityGroupIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
securityGroupIds,
            (Key
"subnetIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
subnetIds,
            (Key
"tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"namespaceName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
namespaceName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"workgroupName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
workgroupName)
          ]
      )

instance Data.ToPath CreateWorkgroup where
  toPath :: CreateWorkgroup -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery CreateWorkgroup where
  toQuery :: CreateWorkgroup -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCreateWorkgroupResponse' smart constructor.
data CreateWorkgroupResponse = CreateWorkgroupResponse'
  { -- | The created workgroup object.
    CreateWorkgroupResponse -> Maybe Workgroup
workgroup :: Prelude.Maybe Workgroup,
    -- | The response's http status code.
    CreateWorkgroupResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateWorkgroupResponse -> CreateWorkgroupResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateWorkgroupResponse -> CreateWorkgroupResponse -> Bool
$c/= :: CreateWorkgroupResponse -> CreateWorkgroupResponse -> Bool
== :: CreateWorkgroupResponse -> CreateWorkgroupResponse -> Bool
$c== :: CreateWorkgroupResponse -> CreateWorkgroupResponse -> Bool
Prelude.Eq, ReadPrec [CreateWorkgroupResponse]
ReadPrec CreateWorkgroupResponse
Int -> ReadS CreateWorkgroupResponse
ReadS [CreateWorkgroupResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateWorkgroupResponse]
$creadListPrec :: ReadPrec [CreateWorkgroupResponse]
readPrec :: ReadPrec CreateWorkgroupResponse
$creadPrec :: ReadPrec CreateWorkgroupResponse
readList :: ReadS [CreateWorkgroupResponse]
$creadList :: ReadS [CreateWorkgroupResponse]
readsPrec :: Int -> ReadS CreateWorkgroupResponse
$creadsPrec :: Int -> ReadS CreateWorkgroupResponse
Prelude.Read, Int -> CreateWorkgroupResponse -> ShowS
[CreateWorkgroupResponse] -> ShowS
CreateWorkgroupResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateWorkgroupResponse] -> ShowS
$cshowList :: [CreateWorkgroupResponse] -> ShowS
show :: CreateWorkgroupResponse -> String
$cshow :: CreateWorkgroupResponse -> String
showsPrec :: Int -> CreateWorkgroupResponse -> ShowS
$cshowsPrec :: Int -> CreateWorkgroupResponse -> ShowS
Prelude.Show, forall x. Rep CreateWorkgroupResponse x -> CreateWorkgroupResponse
forall x. CreateWorkgroupResponse -> Rep CreateWorkgroupResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateWorkgroupResponse x -> CreateWorkgroupResponse
$cfrom :: forall x. CreateWorkgroupResponse -> Rep CreateWorkgroupResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateWorkgroupResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'workgroup', 'createWorkgroupResponse_workgroup' - The created workgroup object.
--
-- 'httpStatus', 'createWorkgroupResponse_httpStatus' - The response's http status code.
newCreateWorkgroupResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateWorkgroupResponse
newCreateWorkgroupResponse :: Int -> CreateWorkgroupResponse
newCreateWorkgroupResponse Int
pHttpStatus_ =
  CreateWorkgroupResponse'
    { $sel:workgroup:CreateWorkgroupResponse' :: Maybe Workgroup
workgroup =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateWorkgroupResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The created workgroup object.
createWorkgroupResponse_workgroup :: Lens.Lens' CreateWorkgroupResponse (Prelude.Maybe Workgroup)
createWorkgroupResponse_workgroup :: Lens' CreateWorkgroupResponse (Maybe Workgroup)
createWorkgroupResponse_workgroup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroupResponse' {Maybe Workgroup
workgroup :: Maybe Workgroup
$sel:workgroup:CreateWorkgroupResponse' :: CreateWorkgroupResponse -> Maybe Workgroup
workgroup} -> Maybe Workgroup
workgroup) (\s :: CreateWorkgroupResponse
s@CreateWorkgroupResponse' {} Maybe Workgroup
a -> CreateWorkgroupResponse
s {$sel:workgroup:CreateWorkgroupResponse' :: Maybe Workgroup
workgroup = Maybe Workgroup
a} :: CreateWorkgroupResponse)

-- | The response's http status code.
createWorkgroupResponse_httpStatus :: Lens.Lens' CreateWorkgroupResponse Prelude.Int
createWorkgroupResponse_httpStatus :: Lens' CreateWorkgroupResponse Int
createWorkgroupResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateWorkgroupResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateWorkgroupResponse' :: CreateWorkgroupResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateWorkgroupResponse
s@CreateWorkgroupResponse' {} Int
a -> CreateWorkgroupResponse
s {$sel:httpStatus:CreateWorkgroupResponse' :: Int
httpStatus = Int
a} :: CreateWorkgroupResponse)

instance Prelude.NFData CreateWorkgroupResponse where
  rnf :: CreateWorkgroupResponse -> ()
rnf CreateWorkgroupResponse' {Int
Maybe Workgroup
httpStatus :: Int
workgroup :: Maybe Workgroup
$sel:httpStatus:CreateWorkgroupResponse' :: CreateWorkgroupResponse -> Int
$sel:workgroup:CreateWorkgroupResponse' :: CreateWorkgroupResponse -> Maybe Workgroup
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Workgroup
workgroup
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus