{-# 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.MigrationHubReFactorSpaces.CreateService
-- 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 Amazon Web Services Migration Hub Refactor Spaces service.
-- The account owner of the service is always the environment owner,
-- regardless of which account in the environment creates the service.
-- Services have either a URL endpoint in a virtual private cloud (VPC), or
-- a Lambda function endpoint.
--
-- If an Amazon Web Services resource is launched in a service VPC, and you
-- want it to be accessible to all of an environment’s services with VPCs
-- and routes, apply the @RefactorSpacesSecurityGroup@ to the resource.
-- Alternatively, to add more cross-account constraints, apply your own
-- security group.
module Amazonka.MigrationHubReFactorSpaces.CreateService
  ( -- * Creating a Request
    CreateService (..),
    newCreateService,

    -- * Request Lenses
    createService_clientToken,
    createService_description,
    createService_lambdaEndpoint,
    createService_tags,
    createService_urlEndpoint,
    createService_vpcId,
    createService_applicationIdentifier,
    createService_endpointType,
    createService_environmentIdentifier,
    createService_name,

    -- * Destructuring the Response
    CreateServiceResponse (..),
    newCreateServiceResponse,

    -- * Response Lenses
    createServiceResponse_applicationId,
    createServiceResponse_arn,
    createServiceResponse_createdByAccountId,
    createServiceResponse_createdTime,
    createServiceResponse_description,
    createServiceResponse_endpointType,
    createServiceResponse_environmentId,
    createServiceResponse_lambdaEndpoint,
    createServiceResponse_lastUpdatedTime,
    createServiceResponse_name,
    createServiceResponse_ownerAccountId,
    createServiceResponse_serviceId,
    createServiceResponse_state,
    createServiceResponse_tags,
    createServiceResponse_urlEndpoint,
    createServiceResponse_vpcId,
    createServiceResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateService' smart constructor.
data CreateService = CreateService'
  { -- | A unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request.
    CreateService -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The description of the service.
    CreateService -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The configuration for the Lambda endpoint type.
    CreateService -> Maybe LambdaEndpointInput
lambdaEndpoint :: Prelude.Maybe LambdaEndpointInput,
    -- | The tags to assign to the service. A tag is a label that you assign to
    -- an Amazon Web Services resource. Each tag consists of a key-value pair..
    CreateService -> Maybe (Sensitive (HashMap Text Text))
tags :: Prelude.Maybe (Data.Sensitive (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | The configuration for the URL endpoint type. When creating a route to a
    -- service, Refactor Spaces automatically resolves the address in the
    -- @UrlEndpointInput@ object URL when the Domain Name System (DNS)
    -- time-to-live (TTL) expires, or every 60 seconds for TTLs less than 60
    -- seconds.
    CreateService -> Maybe UrlEndpointInput
urlEndpoint :: Prelude.Maybe UrlEndpointInput,
    -- | The ID of the VPC.
    CreateService -> Maybe Text
vpcId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the application which the service is created.
    CreateService -> Text
applicationIdentifier :: Prelude.Text,
    -- | The type of endpoint to use for the service. The type can be a URL in a
    -- VPC or an Lambda function.
    CreateService -> ServiceEndpointType
endpointType :: ServiceEndpointType,
    -- | The ID of the environment in which the service is created.
    CreateService -> Text
environmentIdentifier :: Prelude.Text,
    -- | The name of the service.
    CreateService -> Text
name :: Prelude.Text
  }
  deriving (CreateService -> CreateService -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateService -> CreateService -> Bool
$c/= :: CreateService -> CreateService -> Bool
== :: CreateService -> CreateService -> Bool
$c== :: CreateService -> CreateService -> Bool
Prelude.Eq, Int -> CreateService -> ShowS
[CreateService] -> ShowS
CreateService -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateService] -> ShowS
$cshowList :: [CreateService] -> ShowS
show :: CreateService -> String
$cshow :: CreateService -> String
showsPrec :: Int -> CreateService -> ShowS
$cshowsPrec :: Int -> CreateService -> ShowS
Prelude.Show, forall x. Rep CreateService x -> CreateService
forall x. CreateService -> Rep CreateService x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateService x -> CreateService
$cfrom :: forall x. CreateService -> Rep CreateService x
Prelude.Generic)

-- |
-- Create a value of 'CreateService' 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:
--
-- 'clientToken', 'createService_clientToken' - A unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
--
-- 'description', 'createService_description' - The description of the service.
--
-- 'lambdaEndpoint', 'createService_lambdaEndpoint' - The configuration for the Lambda endpoint type.
--
-- 'tags', 'createService_tags' - The tags to assign to the service. A tag is a label that you assign to
-- an Amazon Web Services resource. Each tag consists of a key-value pair..
--
-- 'urlEndpoint', 'createService_urlEndpoint' - The configuration for the URL endpoint type. When creating a route to a
-- service, Refactor Spaces automatically resolves the address in the
-- @UrlEndpointInput@ object URL when the Domain Name System (DNS)
-- time-to-live (TTL) expires, or every 60 seconds for TTLs less than 60
-- seconds.
--
-- 'vpcId', 'createService_vpcId' - The ID of the VPC.
--
-- 'applicationIdentifier', 'createService_applicationIdentifier' - The ID of the application which the service is created.
--
-- 'endpointType', 'createService_endpointType' - The type of endpoint to use for the service. The type can be a URL in a
-- VPC or an Lambda function.
--
-- 'environmentIdentifier', 'createService_environmentIdentifier' - The ID of the environment in which the service is created.
--
-- 'name', 'createService_name' - The name of the service.
newCreateService ::
  -- | 'applicationIdentifier'
  Prelude.Text ->
  -- | 'endpointType'
  ServiceEndpointType ->
  -- | 'environmentIdentifier'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  CreateService
newCreateService :: Text -> ServiceEndpointType -> Text -> Text -> CreateService
newCreateService
  Text
pApplicationIdentifier_
  ServiceEndpointType
pEndpointType_
  Text
pEnvironmentIdentifier_
  Text
pName_ =
    CreateService'
      { $sel:clientToken:CreateService' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
        $sel:description:CreateService' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:lambdaEndpoint:CreateService' :: Maybe LambdaEndpointInput
lambdaEndpoint = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateService' :: Maybe (Sensitive (HashMap Text Text))
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:urlEndpoint:CreateService' :: Maybe UrlEndpointInput
urlEndpoint = forall a. Maybe a
Prelude.Nothing,
        $sel:vpcId:CreateService' :: Maybe Text
vpcId = forall a. Maybe a
Prelude.Nothing,
        $sel:applicationIdentifier:CreateService' :: Text
applicationIdentifier = Text
pApplicationIdentifier_,
        $sel:endpointType:CreateService' :: ServiceEndpointType
endpointType = ServiceEndpointType
pEndpointType_,
        $sel:environmentIdentifier:CreateService' :: Text
environmentIdentifier = Text
pEnvironmentIdentifier_,
        $sel:name:CreateService' :: Text
name = Text
pName_
      }

-- | A unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
createService_clientToken :: Lens.Lens' CreateService (Prelude.Maybe Prelude.Text)
createService_clientToken :: Lens' CreateService (Maybe Text)
createService_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateService' :: CreateService -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateService
s@CreateService' {} Maybe Text
a -> CreateService
s {$sel:clientToken:CreateService' :: Maybe Text
clientToken = Maybe Text
a} :: CreateService)

-- | The description of the service.
createService_description :: Lens.Lens' CreateService (Prelude.Maybe Prelude.Text)
createService_description :: Lens' CreateService (Maybe Text)
createService_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Maybe Text
description :: Maybe Text
$sel:description:CreateService' :: CreateService -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateService
s@CreateService' {} Maybe Text
a -> CreateService
s {$sel:description:CreateService' :: Maybe Text
description = Maybe Text
a} :: CreateService)

-- | The configuration for the Lambda endpoint type.
createService_lambdaEndpoint :: Lens.Lens' CreateService (Prelude.Maybe LambdaEndpointInput)
createService_lambdaEndpoint :: Lens' CreateService (Maybe LambdaEndpointInput)
createService_lambdaEndpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Maybe LambdaEndpointInput
lambdaEndpoint :: Maybe LambdaEndpointInput
$sel:lambdaEndpoint:CreateService' :: CreateService -> Maybe LambdaEndpointInput
lambdaEndpoint} -> Maybe LambdaEndpointInput
lambdaEndpoint) (\s :: CreateService
s@CreateService' {} Maybe LambdaEndpointInput
a -> CreateService
s {$sel:lambdaEndpoint:CreateService' :: Maybe LambdaEndpointInput
lambdaEndpoint = Maybe LambdaEndpointInput
a} :: CreateService)

-- | The tags to assign to the service. A tag is a label that you assign to
-- an Amazon Web Services resource. Each tag consists of a key-value pair..
createService_tags :: Lens.Lens' CreateService (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createService_tags :: Lens' CreateService (Maybe (HashMap Text Text))
createService_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Maybe (Sensitive (HashMap Text Text))
tags :: Maybe (Sensitive (HashMap Text Text))
$sel:tags:CreateService' :: CreateService -> Maybe (Sensitive (HashMap Text Text))
tags} -> Maybe (Sensitive (HashMap Text Text))
tags) (\s :: CreateService
s@CreateService' {} Maybe (Sensitive (HashMap Text Text))
a -> CreateService
s {$sel:tags:CreateService' :: Maybe (Sensitive (HashMap Text Text))
tags = Maybe (Sensitive (HashMap Text Text))
a} :: CreateService) 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 a. Iso' (Sensitive a) a
Data._Sensitive forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | The configuration for the URL endpoint type. When creating a route to a
-- service, Refactor Spaces automatically resolves the address in the
-- @UrlEndpointInput@ object URL when the Domain Name System (DNS)
-- time-to-live (TTL) expires, or every 60 seconds for TTLs less than 60
-- seconds.
createService_urlEndpoint :: Lens.Lens' CreateService (Prelude.Maybe UrlEndpointInput)
createService_urlEndpoint :: Lens' CreateService (Maybe UrlEndpointInput)
createService_urlEndpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Maybe UrlEndpointInput
urlEndpoint :: Maybe UrlEndpointInput
$sel:urlEndpoint:CreateService' :: CreateService -> Maybe UrlEndpointInput
urlEndpoint} -> Maybe UrlEndpointInput
urlEndpoint) (\s :: CreateService
s@CreateService' {} Maybe UrlEndpointInput
a -> CreateService
s {$sel:urlEndpoint:CreateService' :: Maybe UrlEndpointInput
urlEndpoint = Maybe UrlEndpointInput
a} :: CreateService)

-- | The ID of the VPC.
createService_vpcId :: Lens.Lens' CreateService (Prelude.Maybe Prelude.Text)
createService_vpcId :: Lens' CreateService (Maybe Text)
createService_vpcId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Maybe Text
vpcId :: Maybe Text
$sel:vpcId:CreateService' :: CreateService -> Maybe Text
vpcId} -> Maybe Text
vpcId) (\s :: CreateService
s@CreateService' {} Maybe Text
a -> CreateService
s {$sel:vpcId:CreateService' :: Maybe Text
vpcId = Maybe Text
a} :: CreateService)

-- | The ID of the application which the service is created.
createService_applicationIdentifier :: Lens.Lens' CreateService Prelude.Text
createService_applicationIdentifier :: Lens' CreateService Text
createService_applicationIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Text
applicationIdentifier :: Text
$sel:applicationIdentifier:CreateService' :: CreateService -> Text
applicationIdentifier} -> Text
applicationIdentifier) (\s :: CreateService
s@CreateService' {} Text
a -> CreateService
s {$sel:applicationIdentifier:CreateService' :: Text
applicationIdentifier = Text
a} :: CreateService)

-- | The type of endpoint to use for the service. The type can be a URL in a
-- VPC or an Lambda function.
createService_endpointType :: Lens.Lens' CreateService ServiceEndpointType
createService_endpointType :: Lens' CreateService ServiceEndpointType
createService_endpointType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {ServiceEndpointType
endpointType :: ServiceEndpointType
$sel:endpointType:CreateService' :: CreateService -> ServiceEndpointType
endpointType} -> ServiceEndpointType
endpointType) (\s :: CreateService
s@CreateService' {} ServiceEndpointType
a -> CreateService
s {$sel:endpointType:CreateService' :: ServiceEndpointType
endpointType = ServiceEndpointType
a} :: CreateService)

-- | The ID of the environment in which the service is created.
createService_environmentIdentifier :: Lens.Lens' CreateService Prelude.Text
createService_environmentIdentifier :: Lens' CreateService Text
createService_environmentIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Text
environmentIdentifier :: Text
$sel:environmentIdentifier:CreateService' :: CreateService -> Text
environmentIdentifier} -> Text
environmentIdentifier) (\s :: CreateService
s@CreateService' {} Text
a -> CreateService
s {$sel:environmentIdentifier:CreateService' :: Text
environmentIdentifier = Text
a} :: CreateService)

-- | The name of the service.
createService_name :: Lens.Lens' CreateService Prelude.Text
createService_name :: Lens' CreateService Text
createService_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateService' {Text
name :: Text
$sel:name:CreateService' :: CreateService -> Text
name} -> Text
name) (\s :: CreateService
s@CreateService' {} Text
a -> CreateService
s {$sel:name:CreateService' :: Text
name = Text
a} :: CreateService)

instance Core.AWSRequest CreateService where
  type
    AWSResponse CreateService =
      CreateServiceResponse
  request :: (Service -> Service) -> CreateService -> Request CreateService
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 CreateService
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateService)))
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 Text
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe ServiceEndpointType
-> Maybe Text
-> Maybe LambdaEndpointInput
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe ServiceState
-> Maybe (Sensitive (HashMap Text Text))
-> Maybe UrlEndpointInput
-> Maybe Text
-> Int
-> CreateServiceResponse
CreateServiceResponse'
            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
"ApplicationId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Arn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"CreatedByAccountId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"CreatedTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Description")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"EndpointType")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"EnvironmentId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"LambdaEndpoint")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"LastUpdatedTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"OwnerAccountId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ServiceId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"State")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Tags" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"UrlEndpoint")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"VpcId")
            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 CreateService where
  hashWithSalt :: Int -> CreateService -> Int
hashWithSalt Int
_salt CreateService' {Maybe Text
Maybe (Sensitive (HashMap Text Text))
Maybe LambdaEndpointInput
Maybe UrlEndpointInput
Text
ServiceEndpointType
name :: Text
environmentIdentifier :: Text
endpointType :: ServiceEndpointType
applicationIdentifier :: Text
vpcId :: Maybe Text
urlEndpoint :: Maybe UrlEndpointInput
tags :: Maybe (Sensitive (HashMap Text Text))
lambdaEndpoint :: Maybe LambdaEndpointInput
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateService' :: CreateService -> Text
$sel:environmentIdentifier:CreateService' :: CreateService -> Text
$sel:endpointType:CreateService' :: CreateService -> ServiceEndpointType
$sel:applicationIdentifier:CreateService' :: CreateService -> Text
$sel:vpcId:CreateService' :: CreateService -> Maybe Text
$sel:urlEndpoint:CreateService' :: CreateService -> Maybe UrlEndpointInput
$sel:tags:CreateService' :: CreateService -> Maybe (Sensitive (HashMap Text Text))
$sel:lambdaEndpoint:CreateService' :: CreateService -> Maybe LambdaEndpointInput
$sel:description:CreateService' :: CreateService -> Maybe Text
$sel:clientToken:CreateService' :: CreateService -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LambdaEndpointInput
lambdaEndpoint
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive (HashMap Text Text))
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UrlEndpointInput
urlEndpoint
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
vpcId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
applicationIdentifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ServiceEndpointType
endpointType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
environmentIdentifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateService where
  rnf :: CreateService -> ()
rnf CreateService' {Maybe Text
Maybe (Sensitive (HashMap Text Text))
Maybe LambdaEndpointInput
Maybe UrlEndpointInput
Text
ServiceEndpointType
name :: Text
environmentIdentifier :: Text
endpointType :: ServiceEndpointType
applicationIdentifier :: Text
vpcId :: Maybe Text
urlEndpoint :: Maybe UrlEndpointInput
tags :: Maybe (Sensitive (HashMap Text Text))
lambdaEndpoint :: Maybe LambdaEndpointInput
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateService' :: CreateService -> Text
$sel:environmentIdentifier:CreateService' :: CreateService -> Text
$sel:endpointType:CreateService' :: CreateService -> ServiceEndpointType
$sel:applicationIdentifier:CreateService' :: CreateService -> Text
$sel:vpcId:CreateService' :: CreateService -> Maybe Text
$sel:urlEndpoint:CreateService' :: CreateService -> Maybe UrlEndpointInput
$sel:tags:CreateService' :: CreateService -> Maybe (Sensitive (HashMap Text Text))
$sel:lambdaEndpoint:CreateService' :: CreateService -> Maybe LambdaEndpointInput
$sel:description:CreateService' :: CreateService -> Maybe Text
$sel:clientToken:CreateService' :: CreateService -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LambdaEndpointInput
lambdaEndpoint
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive (HashMap Text Text))
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UrlEndpointInput
urlEndpoint
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
vpcId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
applicationIdentifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ServiceEndpointType
endpointType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
environmentIdentifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name

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

instance Data.ToJSON CreateService where
  toJSON :: CreateService -> Value
toJSON CreateService' {Maybe Text
Maybe (Sensitive (HashMap Text Text))
Maybe LambdaEndpointInput
Maybe UrlEndpointInput
Text
ServiceEndpointType
name :: Text
environmentIdentifier :: Text
endpointType :: ServiceEndpointType
applicationIdentifier :: Text
vpcId :: Maybe Text
urlEndpoint :: Maybe UrlEndpointInput
tags :: Maybe (Sensitive (HashMap Text Text))
lambdaEndpoint :: Maybe LambdaEndpointInput
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateService' :: CreateService -> Text
$sel:environmentIdentifier:CreateService' :: CreateService -> Text
$sel:endpointType:CreateService' :: CreateService -> ServiceEndpointType
$sel:applicationIdentifier:CreateService' :: CreateService -> Text
$sel:vpcId:CreateService' :: CreateService -> Maybe Text
$sel:urlEndpoint:CreateService' :: CreateService -> Maybe UrlEndpointInput
$sel:tags:CreateService' :: CreateService -> Maybe (Sensitive (HashMap Text Text))
$sel:lambdaEndpoint:CreateService' :: CreateService -> Maybe LambdaEndpointInput
$sel:description:CreateService' :: CreateService -> Maybe Text
$sel:clientToken:CreateService' :: CreateService -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientToken" 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
clientToken,
            (Key
"Description" 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
description,
            (Key
"LambdaEndpoint" 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 LambdaEndpointInput
lambdaEndpoint,
            (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 (Sensitive (HashMap Text Text))
tags,
            (Key
"UrlEndpoint" 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 UrlEndpointInput
urlEndpoint,
            (Key
"VpcId" 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
vpcId,
            forall a. a -> Maybe a
Prelude.Just (Key
"EndpointType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ServiceEndpointType
endpointType),
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

instance Data.ToPath CreateService where
  toPath :: CreateService -> ByteString
toPath CreateService' {Maybe Text
Maybe (Sensitive (HashMap Text Text))
Maybe LambdaEndpointInput
Maybe UrlEndpointInput
Text
ServiceEndpointType
name :: Text
environmentIdentifier :: Text
endpointType :: ServiceEndpointType
applicationIdentifier :: Text
vpcId :: Maybe Text
urlEndpoint :: Maybe UrlEndpointInput
tags :: Maybe (Sensitive (HashMap Text Text))
lambdaEndpoint :: Maybe LambdaEndpointInput
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateService' :: CreateService -> Text
$sel:environmentIdentifier:CreateService' :: CreateService -> Text
$sel:endpointType:CreateService' :: CreateService -> ServiceEndpointType
$sel:applicationIdentifier:CreateService' :: CreateService -> Text
$sel:vpcId:CreateService' :: CreateService -> Maybe Text
$sel:urlEndpoint:CreateService' :: CreateService -> Maybe UrlEndpointInput
$sel:tags:CreateService' :: CreateService -> Maybe (Sensitive (HashMap Text Text))
$sel:lambdaEndpoint:CreateService' :: CreateService -> Maybe LambdaEndpointInput
$sel:description:CreateService' :: CreateService -> Maybe Text
$sel:clientToken:CreateService' :: CreateService -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/environments/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
environmentIdentifier,
        ByteString
"/applications/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
applicationIdentifier,
        ByteString
"/services"
      ]

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

-- | /See:/ 'newCreateServiceResponse' smart constructor.
data CreateServiceResponse = CreateServiceResponse'
  { -- | The ID of the application that the created service belongs to.
    CreateServiceResponse -> Maybe Text
applicationId :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the service.
    CreateServiceResponse -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Web Services account ID of the service creator.
    CreateServiceResponse -> Maybe Text
createdByAccountId :: Prelude.Maybe Prelude.Text,
    -- | A timestamp that indicates when the service is created.
    CreateServiceResponse -> Maybe POSIX
createdTime :: Prelude.Maybe Data.POSIX,
    -- | The description of the created service.
    CreateServiceResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The endpoint type of the service.
    CreateServiceResponse -> Maybe ServiceEndpointType
endpointType :: Prelude.Maybe ServiceEndpointType,
    -- | The unique identifier of the environment.
    CreateServiceResponse -> Maybe Text
environmentId :: Prelude.Maybe Prelude.Text,
    -- | The configuration for the Lambda endpoint type.
    CreateServiceResponse -> Maybe LambdaEndpointInput
lambdaEndpoint :: Prelude.Maybe LambdaEndpointInput,
    -- | A timestamp that indicates when the service was last updated.
    CreateServiceResponse -> Maybe POSIX
lastUpdatedTime :: Prelude.Maybe Data.POSIX,
    -- | The name of the service.
    CreateServiceResponse -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Web Services account ID of the service owner.
    CreateServiceResponse -> Maybe Text
ownerAccountId :: Prelude.Maybe Prelude.Text,
    -- | The unique identifier of the service.
    CreateServiceResponse -> Maybe Text
serviceId :: Prelude.Maybe Prelude.Text,
    -- | The current state of the service.
    CreateServiceResponse -> Maybe ServiceState
state :: Prelude.Maybe ServiceState,
    -- | The tags assigned to the created service. A tag is a label that you
    -- assign to an Amazon Web Services resource. Each tag consists of a
    -- key-value pair..
    CreateServiceResponse -> Maybe (Sensitive (HashMap Text Text))
tags :: Prelude.Maybe (Data.Sensitive (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | The configuration for the URL endpoint type.
    CreateServiceResponse -> Maybe UrlEndpointInput
urlEndpoint :: Prelude.Maybe UrlEndpointInput,
    -- | The ID of the VPC.
    CreateServiceResponse -> Maybe Text
vpcId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateServiceResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateServiceResponse -> CreateServiceResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateServiceResponse -> CreateServiceResponse -> Bool
$c/= :: CreateServiceResponse -> CreateServiceResponse -> Bool
== :: CreateServiceResponse -> CreateServiceResponse -> Bool
$c== :: CreateServiceResponse -> CreateServiceResponse -> Bool
Prelude.Eq, Int -> CreateServiceResponse -> ShowS
[CreateServiceResponse] -> ShowS
CreateServiceResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateServiceResponse] -> ShowS
$cshowList :: [CreateServiceResponse] -> ShowS
show :: CreateServiceResponse -> String
$cshow :: CreateServiceResponse -> String
showsPrec :: Int -> CreateServiceResponse -> ShowS
$cshowsPrec :: Int -> CreateServiceResponse -> ShowS
Prelude.Show, forall x. Rep CreateServiceResponse x -> CreateServiceResponse
forall x. CreateServiceResponse -> Rep CreateServiceResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateServiceResponse x -> CreateServiceResponse
$cfrom :: forall x. CreateServiceResponse -> Rep CreateServiceResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateServiceResponse' 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:
--
-- 'applicationId', 'createServiceResponse_applicationId' - The ID of the application that the created service belongs to.
--
-- 'arn', 'createServiceResponse_arn' - The Amazon Resource Name (ARN) of the service.
--
-- 'createdByAccountId', 'createServiceResponse_createdByAccountId' - The Amazon Web Services account ID of the service creator.
--
-- 'createdTime', 'createServiceResponse_createdTime' - A timestamp that indicates when the service is created.
--
-- 'description', 'createServiceResponse_description' - The description of the created service.
--
-- 'endpointType', 'createServiceResponse_endpointType' - The endpoint type of the service.
--
-- 'environmentId', 'createServiceResponse_environmentId' - The unique identifier of the environment.
--
-- 'lambdaEndpoint', 'createServiceResponse_lambdaEndpoint' - The configuration for the Lambda endpoint type.
--
-- 'lastUpdatedTime', 'createServiceResponse_lastUpdatedTime' - A timestamp that indicates when the service was last updated.
--
-- 'name', 'createServiceResponse_name' - The name of the service.
--
-- 'ownerAccountId', 'createServiceResponse_ownerAccountId' - The Amazon Web Services account ID of the service owner.
--
-- 'serviceId', 'createServiceResponse_serviceId' - The unique identifier of the service.
--
-- 'state', 'createServiceResponse_state' - The current state of the service.
--
-- 'tags', 'createServiceResponse_tags' - The tags assigned to the created service. A tag is a label that you
-- assign to an Amazon Web Services resource. Each tag consists of a
-- key-value pair..
--
-- 'urlEndpoint', 'createServiceResponse_urlEndpoint' - The configuration for the URL endpoint type.
--
-- 'vpcId', 'createServiceResponse_vpcId' - The ID of the VPC.
--
-- 'httpStatus', 'createServiceResponse_httpStatus' - The response's http status code.
newCreateServiceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateServiceResponse
newCreateServiceResponse :: Int -> CreateServiceResponse
newCreateServiceResponse Int
pHttpStatus_ =
  CreateServiceResponse'
    { $sel:applicationId:CreateServiceResponse' :: Maybe Text
applicationId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:arn:CreateServiceResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:createdByAccountId:CreateServiceResponse' :: Maybe Text
createdByAccountId = forall a. Maybe a
Prelude.Nothing,
      $sel:createdTime:CreateServiceResponse' :: Maybe POSIX
createdTime = forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateServiceResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:endpointType:CreateServiceResponse' :: Maybe ServiceEndpointType
endpointType = forall a. Maybe a
Prelude.Nothing,
      $sel:environmentId:CreateServiceResponse' :: Maybe Text
environmentId = forall a. Maybe a
Prelude.Nothing,
      $sel:lambdaEndpoint:CreateServiceResponse' :: Maybe LambdaEndpointInput
lambdaEndpoint = forall a. Maybe a
Prelude.Nothing,
      $sel:lastUpdatedTime:CreateServiceResponse' :: Maybe POSIX
lastUpdatedTime = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateServiceResponse' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:ownerAccountId:CreateServiceResponse' :: Maybe Text
ownerAccountId = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceId:CreateServiceResponse' :: Maybe Text
serviceId = forall a. Maybe a
Prelude.Nothing,
      $sel:state:CreateServiceResponse' :: Maybe ServiceState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateServiceResponse' :: Maybe (Sensitive (HashMap Text Text))
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:urlEndpoint:CreateServiceResponse' :: Maybe UrlEndpointInput
urlEndpoint = forall a. Maybe a
Prelude.Nothing,
      $sel:vpcId:CreateServiceResponse' :: Maybe Text
vpcId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateServiceResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ID of the application that the created service belongs to.
createServiceResponse_applicationId :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_applicationId :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_applicationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
applicationId :: Maybe Text
$sel:applicationId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
applicationId} -> Maybe Text
applicationId) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:applicationId:CreateServiceResponse' :: Maybe Text
applicationId = Maybe Text
a} :: CreateServiceResponse)

-- | The Amazon Resource Name (ARN) of the service.
createServiceResponse_arn :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_arn :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:arn:CreateServiceResponse' :: Maybe Text
arn = Maybe Text
a} :: CreateServiceResponse)

-- | The Amazon Web Services account ID of the service creator.
createServiceResponse_createdByAccountId :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_createdByAccountId :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_createdByAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
createdByAccountId :: Maybe Text
$sel:createdByAccountId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
createdByAccountId} -> Maybe Text
createdByAccountId) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:createdByAccountId:CreateServiceResponse' :: Maybe Text
createdByAccountId = Maybe Text
a} :: CreateServiceResponse)

-- | A timestamp that indicates when the service is created.
createServiceResponse_createdTime :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.UTCTime)
createServiceResponse_createdTime :: Lens' CreateServiceResponse (Maybe UTCTime)
createServiceResponse_createdTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe POSIX
createdTime :: Maybe POSIX
$sel:createdTime:CreateServiceResponse' :: CreateServiceResponse -> Maybe POSIX
createdTime} -> Maybe POSIX
createdTime) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe POSIX
a -> CreateServiceResponse
s {$sel:createdTime:CreateServiceResponse' :: Maybe POSIX
createdTime = Maybe POSIX
a} :: CreateServiceResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The description of the created service.
createServiceResponse_description :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_description :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
description :: Maybe Text
$sel:description:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:description:CreateServiceResponse' :: Maybe Text
description = Maybe Text
a} :: CreateServiceResponse)

-- | The endpoint type of the service.
createServiceResponse_endpointType :: Lens.Lens' CreateServiceResponse (Prelude.Maybe ServiceEndpointType)
createServiceResponse_endpointType :: Lens' CreateServiceResponse (Maybe ServiceEndpointType)
createServiceResponse_endpointType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe ServiceEndpointType
endpointType :: Maybe ServiceEndpointType
$sel:endpointType:CreateServiceResponse' :: CreateServiceResponse -> Maybe ServiceEndpointType
endpointType} -> Maybe ServiceEndpointType
endpointType) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe ServiceEndpointType
a -> CreateServiceResponse
s {$sel:endpointType:CreateServiceResponse' :: Maybe ServiceEndpointType
endpointType = Maybe ServiceEndpointType
a} :: CreateServiceResponse)

-- | The unique identifier of the environment.
createServiceResponse_environmentId :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_environmentId :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_environmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
environmentId :: Maybe Text
$sel:environmentId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
environmentId} -> Maybe Text
environmentId) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:environmentId:CreateServiceResponse' :: Maybe Text
environmentId = Maybe Text
a} :: CreateServiceResponse)

-- | The configuration for the Lambda endpoint type.
createServiceResponse_lambdaEndpoint :: Lens.Lens' CreateServiceResponse (Prelude.Maybe LambdaEndpointInput)
createServiceResponse_lambdaEndpoint :: Lens' CreateServiceResponse (Maybe LambdaEndpointInput)
createServiceResponse_lambdaEndpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe LambdaEndpointInput
lambdaEndpoint :: Maybe LambdaEndpointInput
$sel:lambdaEndpoint:CreateServiceResponse' :: CreateServiceResponse -> Maybe LambdaEndpointInput
lambdaEndpoint} -> Maybe LambdaEndpointInput
lambdaEndpoint) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe LambdaEndpointInput
a -> CreateServiceResponse
s {$sel:lambdaEndpoint:CreateServiceResponse' :: Maybe LambdaEndpointInput
lambdaEndpoint = Maybe LambdaEndpointInput
a} :: CreateServiceResponse)

-- | A timestamp that indicates when the service was last updated.
createServiceResponse_lastUpdatedTime :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.UTCTime)
createServiceResponse_lastUpdatedTime :: Lens' CreateServiceResponse (Maybe UTCTime)
createServiceResponse_lastUpdatedTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe POSIX
lastUpdatedTime :: Maybe POSIX
$sel:lastUpdatedTime:CreateServiceResponse' :: CreateServiceResponse -> Maybe POSIX
lastUpdatedTime} -> Maybe POSIX
lastUpdatedTime) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe POSIX
a -> CreateServiceResponse
s {$sel:lastUpdatedTime:CreateServiceResponse' :: Maybe POSIX
lastUpdatedTime = Maybe POSIX
a} :: CreateServiceResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The name of the service.
createServiceResponse_name :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_name :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
name :: Maybe Text
$sel:name:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:name:CreateServiceResponse' :: Maybe Text
name = Maybe Text
a} :: CreateServiceResponse)

-- | The Amazon Web Services account ID of the service owner.
createServiceResponse_ownerAccountId :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_ownerAccountId :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_ownerAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
ownerAccountId :: Maybe Text
$sel:ownerAccountId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
ownerAccountId} -> Maybe Text
ownerAccountId) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:ownerAccountId:CreateServiceResponse' :: Maybe Text
ownerAccountId = Maybe Text
a} :: CreateServiceResponse)

-- | The unique identifier of the service.
createServiceResponse_serviceId :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_serviceId :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_serviceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
serviceId :: Maybe Text
$sel:serviceId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
serviceId} -> Maybe Text
serviceId) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:serviceId:CreateServiceResponse' :: Maybe Text
serviceId = Maybe Text
a} :: CreateServiceResponse)

-- | The current state of the service.
createServiceResponse_state :: Lens.Lens' CreateServiceResponse (Prelude.Maybe ServiceState)
createServiceResponse_state :: Lens' CreateServiceResponse (Maybe ServiceState)
createServiceResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe ServiceState
state :: Maybe ServiceState
$sel:state:CreateServiceResponse' :: CreateServiceResponse -> Maybe ServiceState
state} -> Maybe ServiceState
state) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe ServiceState
a -> CreateServiceResponse
s {$sel:state:CreateServiceResponse' :: Maybe ServiceState
state = Maybe ServiceState
a} :: CreateServiceResponse)

-- | The tags assigned to the created service. A tag is a label that you
-- assign to an Amazon Web Services resource. Each tag consists of a
-- key-value pair..
createServiceResponse_tags :: Lens.Lens' CreateServiceResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createServiceResponse_tags :: Lens' CreateServiceResponse (Maybe (HashMap Text Text))
createServiceResponse_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe (Sensitive (HashMap Text Text))
tags :: Maybe (Sensitive (HashMap Text Text))
$sel:tags:CreateServiceResponse' :: CreateServiceResponse -> Maybe (Sensitive (HashMap Text Text))
tags} -> Maybe (Sensitive (HashMap Text Text))
tags) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe (Sensitive (HashMap Text Text))
a -> CreateServiceResponse
s {$sel:tags:CreateServiceResponse' :: Maybe (Sensitive (HashMap Text Text))
tags = Maybe (Sensitive (HashMap Text Text))
a} :: CreateServiceResponse) 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 a. Iso' (Sensitive a) a
Data._Sensitive forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | The configuration for the URL endpoint type.
createServiceResponse_urlEndpoint :: Lens.Lens' CreateServiceResponse (Prelude.Maybe UrlEndpointInput)
createServiceResponse_urlEndpoint :: Lens' CreateServiceResponse (Maybe UrlEndpointInput)
createServiceResponse_urlEndpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe UrlEndpointInput
urlEndpoint :: Maybe UrlEndpointInput
$sel:urlEndpoint:CreateServiceResponse' :: CreateServiceResponse -> Maybe UrlEndpointInput
urlEndpoint} -> Maybe UrlEndpointInput
urlEndpoint) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe UrlEndpointInput
a -> CreateServiceResponse
s {$sel:urlEndpoint:CreateServiceResponse' :: Maybe UrlEndpointInput
urlEndpoint = Maybe UrlEndpointInput
a} :: CreateServiceResponse)

-- | The ID of the VPC.
createServiceResponse_vpcId :: Lens.Lens' CreateServiceResponse (Prelude.Maybe Prelude.Text)
createServiceResponse_vpcId :: Lens' CreateServiceResponse (Maybe Text)
createServiceResponse_vpcId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateServiceResponse' {Maybe Text
vpcId :: Maybe Text
$sel:vpcId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
vpcId} -> Maybe Text
vpcId) (\s :: CreateServiceResponse
s@CreateServiceResponse' {} Maybe Text
a -> CreateServiceResponse
s {$sel:vpcId:CreateServiceResponse' :: Maybe Text
vpcId = Maybe Text
a} :: CreateServiceResponse)

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

instance Prelude.NFData CreateServiceResponse where
  rnf :: CreateServiceResponse -> ()
rnf CreateServiceResponse' {Int
Maybe Text
Maybe (Sensitive (HashMap Text Text))
Maybe POSIX
Maybe LambdaEndpointInput
Maybe ServiceEndpointType
Maybe ServiceState
Maybe UrlEndpointInput
httpStatus :: Int
vpcId :: Maybe Text
urlEndpoint :: Maybe UrlEndpointInput
tags :: Maybe (Sensitive (HashMap Text Text))
state :: Maybe ServiceState
serviceId :: Maybe Text
ownerAccountId :: Maybe Text
name :: Maybe Text
lastUpdatedTime :: Maybe POSIX
lambdaEndpoint :: Maybe LambdaEndpointInput
environmentId :: Maybe Text
endpointType :: Maybe ServiceEndpointType
description :: Maybe Text
createdTime :: Maybe POSIX
createdByAccountId :: Maybe Text
arn :: Maybe Text
applicationId :: Maybe Text
$sel:httpStatus:CreateServiceResponse' :: CreateServiceResponse -> Int
$sel:vpcId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:urlEndpoint:CreateServiceResponse' :: CreateServiceResponse -> Maybe UrlEndpointInput
$sel:tags:CreateServiceResponse' :: CreateServiceResponse -> Maybe (Sensitive (HashMap Text Text))
$sel:state:CreateServiceResponse' :: CreateServiceResponse -> Maybe ServiceState
$sel:serviceId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:ownerAccountId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:name:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:lastUpdatedTime:CreateServiceResponse' :: CreateServiceResponse -> Maybe POSIX
$sel:lambdaEndpoint:CreateServiceResponse' :: CreateServiceResponse -> Maybe LambdaEndpointInput
$sel:environmentId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:endpointType:CreateServiceResponse' :: CreateServiceResponse -> Maybe ServiceEndpointType
$sel:description:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:createdTime:CreateServiceResponse' :: CreateServiceResponse -> Maybe POSIX
$sel:createdByAccountId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:arn:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
$sel:applicationId:CreateServiceResponse' :: CreateServiceResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
applicationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
createdByAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceEndpointType
endpointType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
environmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LambdaEndpointInput
lambdaEndpoint
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastUpdatedTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
ownerAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
serviceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive (HashMap Text Text))
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UrlEndpointInput
urlEndpoint
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
vpcId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus