{-# 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.Forecast.CreateExplainabilityExport
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Exports an Explainability resource created by the CreateExplainability
-- operation. Exported files are exported to an Amazon Simple Storage
-- Service (Amazon S3) bucket.
--
-- You must specify a DataDestination object that includes an Amazon S3
-- bucket and an AWS Identity and Access Management (IAM) role that Amazon
-- Forecast can assume to access the Amazon S3 bucket. For more
-- information, see aws-forecast-iam-roles.
--
-- The @Status@ of the export job must be @ACTIVE@ before you can access
-- the export in your Amazon S3 bucket. To get the status, use the
-- DescribeExplainabilityExport operation.
module Amazonka.Forecast.CreateExplainabilityExport
  ( -- * Creating a Request
    CreateExplainabilityExport (..),
    newCreateExplainabilityExport,

    -- * Request Lenses
    createExplainabilityExport_format,
    createExplainabilityExport_tags,
    createExplainabilityExport_explainabilityExportName,
    createExplainabilityExport_explainabilityArn,
    createExplainabilityExport_destination,

    -- * Destructuring the Response
    CreateExplainabilityExportResponse (..),
    newCreateExplainabilityExportResponse,

    -- * Response Lenses
    createExplainabilityExportResponse_explainabilityExportArn,
    createExplainabilityExportResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateExplainabilityExport' smart constructor.
data CreateExplainabilityExport = CreateExplainabilityExport'
  { -- | The format of the exported data, CSV or PARQUET.
    CreateExplainabilityExport -> Maybe Text
format :: Prelude.Maybe Prelude.Text,
    -- | Optional metadata to help you categorize and organize your resources.
    -- Each tag consists of a key and an optional value, both of which you
    -- define. Tag keys and values are case sensitive.
    --
    -- The following restrictions apply to tags:
    --
    -- -   For each resource, each tag key must be unique and each tag key must
    --     have one value.
    --
    -- -   Maximum number of tags per resource: 50.
    --
    -- -   Maximum key length: 128 Unicode characters in UTF-8.
    --
    -- -   Maximum value length: 256 Unicode characters in UTF-8.
    --
    -- -   Accepted characters: all letters and numbers, spaces representable
    --     in UTF-8, and + - = . _ : \/ \@. If your tagging schema is used
    --     across other services and resources, the character restrictions of
    --     those services also apply.
    --
    -- -   Key prefixes cannot include any upper or lowercase combination of
    --     @aws:@ or @AWS:@. Values can have this prefix. If a tag value has
    --     @aws@ as its prefix but the key does not, Forecast considers it to
    --     be a user tag and will count against the limit of 50 tags. Tags with
    --     only the key prefix of @aws@ do not count against your tags per
    --     resource limit. You cannot edit or delete tag keys with this prefix.
    CreateExplainabilityExport -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | A unique name for the Explainability export.
    CreateExplainabilityExport -> Text
explainabilityExportName :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the Explainability to export.
    CreateExplainabilityExport -> Text
explainabilityArn :: Prelude.Text,
    CreateExplainabilityExport -> DataDestination
destination :: DataDestination
  }
  deriving (CreateExplainabilityExport -> CreateExplainabilityExport -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateExplainabilityExport -> CreateExplainabilityExport -> Bool
$c/= :: CreateExplainabilityExport -> CreateExplainabilityExport -> Bool
== :: CreateExplainabilityExport -> CreateExplainabilityExport -> Bool
$c== :: CreateExplainabilityExport -> CreateExplainabilityExport -> Bool
Prelude.Eq, Int -> CreateExplainabilityExport -> ShowS
[CreateExplainabilityExport] -> ShowS
CreateExplainabilityExport -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateExplainabilityExport] -> ShowS
$cshowList :: [CreateExplainabilityExport] -> ShowS
show :: CreateExplainabilityExport -> String
$cshow :: CreateExplainabilityExport -> String
showsPrec :: Int -> CreateExplainabilityExport -> ShowS
$cshowsPrec :: Int -> CreateExplainabilityExport -> ShowS
Prelude.Show, forall x.
Rep CreateExplainabilityExport x -> CreateExplainabilityExport
forall x.
CreateExplainabilityExport -> Rep CreateExplainabilityExport x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateExplainabilityExport x -> CreateExplainabilityExport
$cfrom :: forall x.
CreateExplainabilityExport -> Rep CreateExplainabilityExport x
Prelude.Generic)

-- |
-- Create a value of 'CreateExplainabilityExport' 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:
--
-- 'format', 'createExplainabilityExport_format' - The format of the exported data, CSV or PARQUET.
--
-- 'tags', 'createExplainabilityExport_tags' - Optional metadata to help you categorize and organize your resources.
-- Each tag consists of a key and an optional value, both of which you
-- define. Tag keys and values are case sensitive.
--
-- The following restrictions apply to tags:
--
-- -   For each resource, each tag key must be unique and each tag key must
--     have one value.
--
-- -   Maximum number of tags per resource: 50.
--
-- -   Maximum key length: 128 Unicode characters in UTF-8.
--
-- -   Maximum value length: 256 Unicode characters in UTF-8.
--
-- -   Accepted characters: all letters and numbers, spaces representable
--     in UTF-8, and + - = . _ : \/ \@. If your tagging schema is used
--     across other services and resources, the character restrictions of
--     those services also apply.
--
-- -   Key prefixes cannot include any upper or lowercase combination of
--     @aws:@ or @AWS:@. Values can have this prefix. If a tag value has
--     @aws@ as its prefix but the key does not, Forecast considers it to
--     be a user tag and will count against the limit of 50 tags. Tags with
--     only the key prefix of @aws@ do not count against your tags per
--     resource limit. You cannot edit or delete tag keys with this prefix.
--
-- 'explainabilityExportName', 'createExplainabilityExport_explainabilityExportName' - A unique name for the Explainability export.
--
-- 'explainabilityArn', 'createExplainabilityExport_explainabilityArn' - The Amazon Resource Name (ARN) of the Explainability to export.
--
-- 'destination', 'createExplainabilityExport_destination' - Undocumented member.
newCreateExplainabilityExport ::
  -- | 'explainabilityExportName'
  Prelude.Text ->
  -- | 'explainabilityArn'
  Prelude.Text ->
  -- | 'destination'
  DataDestination ->
  CreateExplainabilityExport
newCreateExplainabilityExport :: Text -> Text -> DataDestination -> CreateExplainabilityExport
newCreateExplainabilityExport
  Text
pExplainabilityExportName_
  Text
pExplainabilityArn_
  DataDestination
pDestination_ =
    CreateExplainabilityExport'
      { $sel:format:CreateExplainabilityExport' :: Maybe Text
format =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateExplainabilityExport' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:explainabilityExportName:CreateExplainabilityExport' :: Text
explainabilityExportName =
          Text
pExplainabilityExportName_,
        $sel:explainabilityArn:CreateExplainabilityExport' :: Text
explainabilityArn = Text
pExplainabilityArn_,
        $sel:destination:CreateExplainabilityExport' :: DataDestination
destination = DataDestination
pDestination_
      }

-- | The format of the exported data, CSV or PARQUET.
createExplainabilityExport_format :: Lens.Lens' CreateExplainabilityExport (Prelude.Maybe Prelude.Text)
createExplainabilityExport_format :: Lens' CreateExplainabilityExport (Maybe Text)
createExplainabilityExport_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExplainabilityExport' {Maybe Text
format :: Maybe Text
$sel:format:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe Text
format} -> Maybe Text
format) (\s :: CreateExplainabilityExport
s@CreateExplainabilityExport' {} Maybe Text
a -> CreateExplainabilityExport
s {$sel:format:CreateExplainabilityExport' :: Maybe Text
format = Maybe Text
a} :: CreateExplainabilityExport)

-- | Optional metadata to help you categorize and organize your resources.
-- Each tag consists of a key and an optional value, both of which you
-- define. Tag keys and values are case sensitive.
--
-- The following restrictions apply to tags:
--
-- -   For each resource, each tag key must be unique and each tag key must
--     have one value.
--
-- -   Maximum number of tags per resource: 50.
--
-- -   Maximum key length: 128 Unicode characters in UTF-8.
--
-- -   Maximum value length: 256 Unicode characters in UTF-8.
--
-- -   Accepted characters: all letters and numbers, spaces representable
--     in UTF-8, and + - = . _ : \/ \@. If your tagging schema is used
--     across other services and resources, the character restrictions of
--     those services also apply.
--
-- -   Key prefixes cannot include any upper or lowercase combination of
--     @aws:@ or @AWS:@. Values can have this prefix. If a tag value has
--     @aws@ as its prefix but the key does not, Forecast considers it to
--     be a user tag and will count against the limit of 50 tags. Tags with
--     only the key prefix of @aws@ do not count against your tags per
--     resource limit. You cannot edit or delete tag keys with this prefix.
createExplainabilityExport_tags :: Lens.Lens' CreateExplainabilityExport (Prelude.Maybe [Tag])
createExplainabilityExport_tags :: Lens' CreateExplainabilityExport (Maybe [Tag])
createExplainabilityExport_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExplainabilityExport' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateExplainabilityExport
s@CreateExplainabilityExport' {} Maybe [Tag]
a -> CreateExplainabilityExport
s {$sel:tags:CreateExplainabilityExport' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateExplainabilityExport) 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 unique name for the Explainability export.
createExplainabilityExport_explainabilityExportName :: Lens.Lens' CreateExplainabilityExport Prelude.Text
createExplainabilityExport_explainabilityExportName :: Lens' CreateExplainabilityExport Text
createExplainabilityExport_explainabilityExportName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExplainabilityExport' {Text
explainabilityExportName :: Text
$sel:explainabilityExportName:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
explainabilityExportName} -> Text
explainabilityExportName) (\s :: CreateExplainabilityExport
s@CreateExplainabilityExport' {} Text
a -> CreateExplainabilityExport
s {$sel:explainabilityExportName:CreateExplainabilityExport' :: Text
explainabilityExportName = Text
a} :: CreateExplainabilityExport)

-- | The Amazon Resource Name (ARN) of the Explainability to export.
createExplainabilityExport_explainabilityArn :: Lens.Lens' CreateExplainabilityExport Prelude.Text
createExplainabilityExport_explainabilityArn :: Lens' CreateExplainabilityExport Text
createExplainabilityExport_explainabilityArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExplainabilityExport' {Text
explainabilityArn :: Text
$sel:explainabilityArn:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
explainabilityArn} -> Text
explainabilityArn) (\s :: CreateExplainabilityExport
s@CreateExplainabilityExport' {} Text
a -> CreateExplainabilityExport
s {$sel:explainabilityArn:CreateExplainabilityExport' :: Text
explainabilityArn = Text
a} :: CreateExplainabilityExport)

-- | Undocumented member.
createExplainabilityExport_destination :: Lens.Lens' CreateExplainabilityExport DataDestination
createExplainabilityExport_destination :: Lens' CreateExplainabilityExport DataDestination
createExplainabilityExport_destination = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExplainabilityExport' {DataDestination
destination :: DataDestination
$sel:destination:CreateExplainabilityExport' :: CreateExplainabilityExport -> DataDestination
destination} -> DataDestination
destination) (\s :: CreateExplainabilityExport
s@CreateExplainabilityExport' {} DataDestination
a -> CreateExplainabilityExport
s {$sel:destination:CreateExplainabilityExport' :: DataDestination
destination = DataDestination
a} :: CreateExplainabilityExport)

instance Core.AWSRequest CreateExplainabilityExport where
  type
    AWSResponse CreateExplainabilityExport =
      CreateExplainabilityExportResponse
  request :: (Service -> Service)
-> CreateExplainabilityExport -> Request CreateExplainabilityExport
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 CreateExplainabilityExport
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateExplainabilityExport)))
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 -> Int -> CreateExplainabilityExportResponse
CreateExplainabilityExportResponse'
            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
"ExplainabilityExportArn")
            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 CreateExplainabilityExport where
  hashWithSalt :: Int -> CreateExplainabilityExport -> Int
hashWithSalt Int
_salt CreateExplainabilityExport' {Maybe [Tag]
Maybe Text
Text
DataDestination
destination :: DataDestination
explainabilityArn :: Text
explainabilityExportName :: Text
tags :: Maybe [Tag]
format :: Maybe Text
$sel:destination:CreateExplainabilityExport' :: CreateExplainabilityExport -> DataDestination
$sel:explainabilityArn:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
$sel:explainabilityExportName:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
$sel:tags:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe [Tag]
$sel:format:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
format
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
explainabilityExportName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
explainabilityArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` DataDestination
destination

instance Prelude.NFData CreateExplainabilityExport where
  rnf :: CreateExplainabilityExport -> ()
rnf CreateExplainabilityExport' {Maybe [Tag]
Maybe Text
Text
DataDestination
destination :: DataDestination
explainabilityArn :: Text
explainabilityExportName :: Text
tags :: Maybe [Tag]
format :: Maybe Text
$sel:destination:CreateExplainabilityExport' :: CreateExplainabilityExport -> DataDestination
$sel:explainabilityArn:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
$sel:explainabilityExportName:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
$sel:tags:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe [Tag]
$sel:format:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
format
      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
explainabilityExportName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
explainabilityArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DataDestination
destination

instance Data.ToHeaders CreateExplainabilityExport where
  toHeaders :: CreateExplainabilityExport -> 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
"AmazonForecast.CreateExplainabilityExport" ::
                          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 CreateExplainabilityExport where
  toJSON :: CreateExplainabilityExport -> Value
toJSON CreateExplainabilityExport' {Maybe [Tag]
Maybe Text
Text
DataDestination
destination :: DataDestination
explainabilityArn :: Text
explainabilityExportName :: Text
tags :: Maybe [Tag]
format :: Maybe Text
$sel:destination:CreateExplainabilityExport' :: CreateExplainabilityExport -> DataDestination
$sel:explainabilityArn:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
$sel:explainabilityExportName:CreateExplainabilityExport' :: CreateExplainabilityExport -> Text
$sel:tags:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe [Tag]
$sel:format:CreateExplainabilityExport' :: CreateExplainabilityExport -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Format" 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
format,
            (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
"ExplainabilityExportName"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
explainabilityExportName
              ),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ExplainabilityArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
explainabilityArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"Destination" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= DataDestination
destination)
          ]
      )

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

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

-- | /See:/ 'newCreateExplainabilityExportResponse' smart constructor.
data CreateExplainabilityExportResponse = CreateExplainabilityExportResponse'
  { -- | The Amazon Resource Name (ARN) of the export.
    CreateExplainabilityExportResponse -> Maybe Text
explainabilityExportArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateExplainabilityExportResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateExplainabilityExportResponse
-> CreateExplainabilityExportResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateExplainabilityExportResponse
-> CreateExplainabilityExportResponse -> Bool
$c/= :: CreateExplainabilityExportResponse
-> CreateExplainabilityExportResponse -> Bool
== :: CreateExplainabilityExportResponse
-> CreateExplainabilityExportResponse -> Bool
$c== :: CreateExplainabilityExportResponse
-> CreateExplainabilityExportResponse -> Bool
Prelude.Eq, ReadPrec [CreateExplainabilityExportResponse]
ReadPrec CreateExplainabilityExportResponse
Int -> ReadS CreateExplainabilityExportResponse
ReadS [CreateExplainabilityExportResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateExplainabilityExportResponse]
$creadListPrec :: ReadPrec [CreateExplainabilityExportResponse]
readPrec :: ReadPrec CreateExplainabilityExportResponse
$creadPrec :: ReadPrec CreateExplainabilityExportResponse
readList :: ReadS [CreateExplainabilityExportResponse]
$creadList :: ReadS [CreateExplainabilityExportResponse]
readsPrec :: Int -> ReadS CreateExplainabilityExportResponse
$creadsPrec :: Int -> ReadS CreateExplainabilityExportResponse
Prelude.Read, Int -> CreateExplainabilityExportResponse -> ShowS
[CreateExplainabilityExportResponse] -> ShowS
CreateExplainabilityExportResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateExplainabilityExportResponse] -> ShowS
$cshowList :: [CreateExplainabilityExportResponse] -> ShowS
show :: CreateExplainabilityExportResponse -> String
$cshow :: CreateExplainabilityExportResponse -> String
showsPrec :: Int -> CreateExplainabilityExportResponse -> ShowS
$cshowsPrec :: Int -> CreateExplainabilityExportResponse -> ShowS
Prelude.Show, forall x.
Rep CreateExplainabilityExportResponse x
-> CreateExplainabilityExportResponse
forall x.
CreateExplainabilityExportResponse
-> Rep CreateExplainabilityExportResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateExplainabilityExportResponse x
-> CreateExplainabilityExportResponse
$cfrom :: forall x.
CreateExplainabilityExportResponse
-> Rep CreateExplainabilityExportResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateExplainabilityExportResponse' 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:
--
-- 'explainabilityExportArn', 'createExplainabilityExportResponse_explainabilityExportArn' - The Amazon Resource Name (ARN) of the export.
--
-- 'httpStatus', 'createExplainabilityExportResponse_httpStatus' - The response's http status code.
newCreateExplainabilityExportResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateExplainabilityExportResponse
newCreateExplainabilityExportResponse :: Int -> CreateExplainabilityExportResponse
newCreateExplainabilityExportResponse Int
pHttpStatus_ =
  CreateExplainabilityExportResponse'
    { $sel:explainabilityExportArn:CreateExplainabilityExportResponse' :: Maybe Text
explainabilityExportArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateExplainabilityExportResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

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

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