{-# 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.QuickSight.CreateFolder
-- 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 empty shared folder.
module Amazonka.QuickSight.CreateFolder
  ( -- * Creating a Request
    CreateFolder (..),
    newCreateFolder,

    -- * Request Lenses
    createFolder_folderType,
    createFolder_name,
    createFolder_parentFolderArn,
    createFolder_permissions,
    createFolder_tags,
    createFolder_awsAccountId,
    createFolder_folderId,

    -- * Destructuring the Response
    CreateFolderResponse (..),
    newCreateFolderResponse,

    -- * Response Lenses
    createFolderResponse_arn,
    createFolderResponse_folderId,
    createFolderResponse_requestId,
    createFolderResponse_status,
  )
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.QuickSight.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateFolder' smart constructor.
data CreateFolder = CreateFolder'
  { -- | The type of folder. By default, @folderType@ is @SHARED@.
    CreateFolder -> Maybe FolderType
folderType :: Prelude.Maybe FolderType,
    -- | The name of the folder.
    CreateFolder -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) for the parent folder.
    --
    -- @ParentFolderArn@ can be null. An empty @parentFolderArn@ creates a
    -- root-level folder.
    CreateFolder -> Maybe Text
parentFolderArn :: Prelude.Maybe Prelude.Text,
    -- | A structure that describes the principals and the resource-level
    -- permissions of a folder.
    --
    -- To specify no permissions, omit @Permissions@.
    CreateFolder -> Maybe (NonEmpty ResourcePermission)
permissions :: Prelude.Maybe (Prelude.NonEmpty ResourcePermission),
    -- | Tags for the folder.
    CreateFolder -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | The ID for the Amazon Web Services account where you want to create the
    -- folder.
    CreateFolder -> Text
awsAccountId :: Prelude.Text,
    -- | The ID of the folder.
    CreateFolder -> Text
folderId :: Prelude.Text
  }
  deriving (CreateFolder -> CreateFolder -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFolder -> CreateFolder -> Bool
$c/= :: CreateFolder -> CreateFolder -> Bool
== :: CreateFolder -> CreateFolder -> Bool
$c== :: CreateFolder -> CreateFolder -> Bool
Prelude.Eq, ReadPrec [CreateFolder]
ReadPrec CreateFolder
Int -> ReadS CreateFolder
ReadS [CreateFolder]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFolder]
$creadListPrec :: ReadPrec [CreateFolder]
readPrec :: ReadPrec CreateFolder
$creadPrec :: ReadPrec CreateFolder
readList :: ReadS [CreateFolder]
$creadList :: ReadS [CreateFolder]
readsPrec :: Int -> ReadS CreateFolder
$creadsPrec :: Int -> ReadS CreateFolder
Prelude.Read, Int -> CreateFolder -> ShowS
[CreateFolder] -> ShowS
CreateFolder -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFolder] -> ShowS
$cshowList :: [CreateFolder] -> ShowS
show :: CreateFolder -> String
$cshow :: CreateFolder -> String
showsPrec :: Int -> CreateFolder -> ShowS
$cshowsPrec :: Int -> CreateFolder -> ShowS
Prelude.Show, forall x. Rep CreateFolder x -> CreateFolder
forall x. CreateFolder -> Rep CreateFolder x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFolder x -> CreateFolder
$cfrom :: forall x. CreateFolder -> Rep CreateFolder x
Prelude.Generic)

-- |
-- Create a value of 'CreateFolder' 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:
--
-- 'folderType', 'createFolder_folderType' - The type of folder. By default, @folderType@ is @SHARED@.
--
-- 'name', 'createFolder_name' - The name of the folder.
--
-- 'parentFolderArn', 'createFolder_parentFolderArn' - The Amazon Resource Name (ARN) for the parent folder.
--
-- @ParentFolderArn@ can be null. An empty @parentFolderArn@ creates a
-- root-level folder.
--
-- 'permissions', 'createFolder_permissions' - A structure that describes the principals and the resource-level
-- permissions of a folder.
--
-- To specify no permissions, omit @Permissions@.
--
-- 'tags', 'createFolder_tags' - Tags for the folder.
--
-- 'awsAccountId', 'createFolder_awsAccountId' - The ID for the Amazon Web Services account where you want to create the
-- folder.
--
-- 'folderId', 'createFolder_folderId' - The ID of the folder.
newCreateFolder ::
  -- | 'awsAccountId'
  Prelude.Text ->
  -- | 'folderId'
  Prelude.Text ->
  CreateFolder
newCreateFolder :: Text -> Text -> CreateFolder
newCreateFolder Text
pAwsAccountId_ Text
pFolderId_ =
  CreateFolder'
    { $sel:folderType:CreateFolder' :: Maybe FolderType
folderType = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateFolder' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:parentFolderArn:CreateFolder' :: Maybe Text
parentFolderArn = forall a. Maybe a
Prelude.Nothing,
      $sel:permissions:CreateFolder' :: Maybe (NonEmpty ResourcePermission)
permissions = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateFolder' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:awsAccountId:CreateFolder' :: Text
awsAccountId = Text
pAwsAccountId_,
      $sel:folderId:CreateFolder' :: Text
folderId = Text
pFolderId_
    }

-- | The type of folder. By default, @folderType@ is @SHARED@.
createFolder_folderType :: Lens.Lens' CreateFolder (Prelude.Maybe FolderType)
createFolder_folderType :: Lens' CreateFolder (Maybe FolderType)
createFolder_folderType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolder' {Maybe FolderType
folderType :: Maybe FolderType
$sel:folderType:CreateFolder' :: CreateFolder -> Maybe FolderType
folderType} -> Maybe FolderType
folderType) (\s :: CreateFolder
s@CreateFolder' {} Maybe FolderType
a -> CreateFolder
s {$sel:folderType:CreateFolder' :: Maybe FolderType
folderType = Maybe FolderType
a} :: CreateFolder)

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

-- | The Amazon Resource Name (ARN) for the parent folder.
--
-- @ParentFolderArn@ can be null. An empty @parentFolderArn@ creates a
-- root-level folder.
createFolder_parentFolderArn :: Lens.Lens' CreateFolder (Prelude.Maybe Prelude.Text)
createFolder_parentFolderArn :: Lens' CreateFolder (Maybe Text)
createFolder_parentFolderArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolder' {Maybe Text
parentFolderArn :: Maybe Text
$sel:parentFolderArn:CreateFolder' :: CreateFolder -> Maybe Text
parentFolderArn} -> Maybe Text
parentFolderArn) (\s :: CreateFolder
s@CreateFolder' {} Maybe Text
a -> CreateFolder
s {$sel:parentFolderArn:CreateFolder' :: Maybe Text
parentFolderArn = Maybe Text
a} :: CreateFolder)

-- | A structure that describes the principals and the resource-level
-- permissions of a folder.
--
-- To specify no permissions, omit @Permissions@.
createFolder_permissions :: Lens.Lens' CreateFolder (Prelude.Maybe (Prelude.NonEmpty ResourcePermission))
createFolder_permissions :: Lens' CreateFolder (Maybe (NonEmpty ResourcePermission))
createFolder_permissions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolder' {Maybe (NonEmpty ResourcePermission)
permissions :: Maybe (NonEmpty ResourcePermission)
$sel:permissions:CreateFolder' :: CreateFolder -> Maybe (NonEmpty ResourcePermission)
permissions} -> Maybe (NonEmpty ResourcePermission)
permissions) (\s :: CreateFolder
s@CreateFolder' {} Maybe (NonEmpty ResourcePermission)
a -> CreateFolder
s {$sel:permissions:CreateFolder' :: Maybe (NonEmpty ResourcePermission)
permissions = Maybe (NonEmpty ResourcePermission)
a} :: CreateFolder) 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

-- | Tags for the folder.
createFolder_tags :: Lens.Lens' CreateFolder (Prelude.Maybe (Prelude.NonEmpty Tag))
createFolder_tags :: Lens' CreateFolder (Maybe (NonEmpty Tag))
createFolder_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolder' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:CreateFolder' :: CreateFolder -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: CreateFolder
s@CreateFolder' {} Maybe (NonEmpty Tag)
a -> CreateFolder
s {$sel:tags:CreateFolder' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: CreateFolder) 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 ID for the Amazon Web Services account where you want to create the
-- folder.
createFolder_awsAccountId :: Lens.Lens' CreateFolder Prelude.Text
createFolder_awsAccountId :: Lens' CreateFolder Text
createFolder_awsAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolder' {Text
awsAccountId :: Text
$sel:awsAccountId:CreateFolder' :: CreateFolder -> Text
awsAccountId} -> Text
awsAccountId) (\s :: CreateFolder
s@CreateFolder' {} Text
a -> CreateFolder
s {$sel:awsAccountId:CreateFolder' :: Text
awsAccountId = Text
a} :: CreateFolder)

-- | The ID of the folder.
createFolder_folderId :: Lens.Lens' CreateFolder Prelude.Text
createFolder_folderId :: Lens' CreateFolder Text
createFolder_folderId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolder' {Text
folderId :: Text
$sel:folderId:CreateFolder' :: CreateFolder -> Text
folderId} -> Text
folderId) (\s :: CreateFolder
s@CreateFolder' {} Text
a -> CreateFolder
s {$sel:folderId:CreateFolder' :: Text
folderId = Text
a} :: CreateFolder)

instance Core.AWSRequest CreateFolder where
  type AWSResponse CreateFolder = CreateFolderResponse
  request :: (Service -> Service) -> CreateFolder -> Request CreateFolder
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 CreateFolder
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateFolder)))
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 -> Int -> CreateFolderResponse
CreateFolderResponse'
            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
"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
"FolderId")
            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
"RequestId")
            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 CreateFolder where
  hashWithSalt :: Int -> CreateFolder -> Int
hashWithSalt Int
_salt CreateFolder' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe FolderType
Text
folderId :: Text
awsAccountId :: Text
tags :: Maybe (NonEmpty Tag)
permissions :: Maybe (NonEmpty ResourcePermission)
parentFolderArn :: Maybe Text
name :: Maybe Text
folderType :: Maybe FolderType
$sel:folderId:CreateFolder' :: CreateFolder -> Text
$sel:awsAccountId:CreateFolder' :: CreateFolder -> Text
$sel:tags:CreateFolder' :: CreateFolder -> Maybe (NonEmpty Tag)
$sel:permissions:CreateFolder' :: CreateFolder -> Maybe (NonEmpty ResourcePermission)
$sel:parentFolderArn:CreateFolder' :: CreateFolder -> Maybe Text
$sel:name:CreateFolder' :: CreateFolder -> Maybe Text
$sel:folderType:CreateFolder' :: CreateFolder -> Maybe FolderType
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FolderType
folderType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
parentFolderArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty ResourcePermission)
permissions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
awsAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
folderId

instance Prelude.NFData CreateFolder where
  rnf :: CreateFolder -> ()
rnf CreateFolder' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe FolderType
Text
folderId :: Text
awsAccountId :: Text
tags :: Maybe (NonEmpty Tag)
permissions :: Maybe (NonEmpty ResourcePermission)
parentFolderArn :: Maybe Text
name :: Maybe Text
folderType :: Maybe FolderType
$sel:folderId:CreateFolder' :: CreateFolder -> Text
$sel:awsAccountId:CreateFolder' :: CreateFolder -> Text
$sel:tags:CreateFolder' :: CreateFolder -> Maybe (NonEmpty Tag)
$sel:permissions:CreateFolder' :: CreateFolder -> Maybe (NonEmpty ResourcePermission)
$sel:parentFolderArn:CreateFolder' :: CreateFolder -> Maybe Text
$sel:name:CreateFolder' :: CreateFolder -> Maybe Text
$sel:folderType:CreateFolder' :: CreateFolder -> Maybe FolderType
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe FolderType
folderType
      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
parentFolderArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty ResourcePermission)
permissions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
awsAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
folderId

instance Data.ToHeaders CreateFolder where
  toHeaders :: CreateFolder -> 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.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateFolder where
  toJSON :: CreateFolder -> Value
toJSON CreateFolder' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe FolderType
Text
folderId :: Text
awsAccountId :: Text
tags :: Maybe (NonEmpty Tag)
permissions :: Maybe (NonEmpty ResourcePermission)
parentFolderArn :: Maybe Text
name :: Maybe Text
folderType :: Maybe FolderType
$sel:folderId:CreateFolder' :: CreateFolder -> Text
$sel:awsAccountId:CreateFolder' :: CreateFolder -> Text
$sel:tags:CreateFolder' :: CreateFolder -> Maybe (NonEmpty Tag)
$sel:permissions:CreateFolder' :: CreateFolder -> Maybe (NonEmpty ResourcePermission)
$sel:parentFolderArn:CreateFolder' :: CreateFolder -> Maybe Text
$sel:name:CreateFolder' :: CreateFolder -> Maybe Text
$sel:folderType:CreateFolder' :: CreateFolder -> Maybe FolderType
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"FolderType" 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 FolderType
folderType,
            (Key
"Name" 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
name,
            (Key
"ParentFolderArn" 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
parentFolderArn,
            (Key
"Permissions" 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 (NonEmpty ResourcePermission)
permissions,
            (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 (NonEmpty Tag)
tags
          ]
      )

instance Data.ToPath CreateFolder where
  toPath :: CreateFolder -> ByteString
toPath CreateFolder' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe FolderType
Text
folderId :: Text
awsAccountId :: Text
tags :: Maybe (NonEmpty Tag)
permissions :: Maybe (NonEmpty ResourcePermission)
parentFolderArn :: Maybe Text
name :: Maybe Text
folderType :: Maybe FolderType
$sel:folderId:CreateFolder' :: CreateFolder -> Text
$sel:awsAccountId:CreateFolder' :: CreateFolder -> Text
$sel:tags:CreateFolder' :: CreateFolder -> Maybe (NonEmpty Tag)
$sel:permissions:CreateFolder' :: CreateFolder -> Maybe (NonEmpty ResourcePermission)
$sel:parentFolderArn:CreateFolder' :: CreateFolder -> Maybe Text
$sel:name:CreateFolder' :: CreateFolder -> Maybe Text
$sel:folderType:CreateFolder' :: CreateFolder -> Maybe FolderType
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/accounts/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
awsAccountId,
        ByteString
"/folders/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
folderId
      ]

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

-- | /See:/ 'newCreateFolderResponse' smart constructor.
data CreateFolderResponse = CreateFolderResponse'
  { -- | The Amazon Resource Name (ARN) for the newly created folder.
    CreateFolderResponse -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The folder ID for the newly created folder.
    CreateFolderResponse -> Maybe Text
folderId :: Prelude.Maybe Prelude.Text,
    -- | The request ID for the newly created folder.
    CreateFolderResponse -> Maybe Text
requestId :: Prelude.Maybe Prelude.Text,
    -- | The HTTP status of the request.
    CreateFolderResponse -> Int
status :: Prelude.Int
  }
  deriving (CreateFolderResponse -> CreateFolderResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFolderResponse -> CreateFolderResponse -> Bool
$c/= :: CreateFolderResponse -> CreateFolderResponse -> Bool
== :: CreateFolderResponse -> CreateFolderResponse -> Bool
$c== :: CreateFolderResponse -> CreateFolderResponse -> Bool
Prelude.Eq, ReadPrec [CreateFolderResponse]
ReadPrec CreateFolderResponse
Int -> ReadS CreateFolderResponse
ReadS [CreateFolderResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFolderResponse]
$creadListPrec :: ReadPrec [CreateFolderResponse]
readPrec :: ReadPrec CreateFolderResponse
$creadPrec :: ReadPrec CreateFolderResponse
readList :: ReadS [CreateFolderResponse]
$creadList :: ReadS [CreateFolderResponse]
readsPrec :: Int -> ReadS CreateFolderResponse
$creadsPrec :: Int -> ReadS CreateFolderResponse
Prelude.Read, Int -> CreateFolderResponse -> ShowS
[CreateFolderResponse] -> ShowS
CreateFolderResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFolderResponse] -> ShowS
$cshowList :: [CreateFolderResponse] -> ShowS
show :: CreateFolderResponse -> String
$cshow :: CreateFolderResponse -> String
showsPrec :: Int -> CreateFolderResponse -> ShowS
$cshowsPrec :: Int -> CreateFolderResponse -> ShowS
Prelude.Show, forall x. Rep CreateFolderResponse x -> CreateFolderResponse
forall x. CreateFolderResponse -> Rep CreateFolderResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFolderResponse x -> CreateFolderResponse
$cfrom :: forall x. CreateFolderResponse -> Rep CreateFolderResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateFolderResponse' 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:
--
-- 'arn', 'createFolderResponse_arn' - The Amazon Resource Name (ARN) for the newly created folder.
--
-- 'folderId', 'createFolderResponse_folderId' - The folder ID for the newly created folder.
--
-- 'requestId', 'createFolderResponse_requestId' - The request ID for the newly created folder.
--
-- 'status', 'createFolderResponse_status' - The HTTP status of the request.
newCreateFolderResponse ::
  -- | 'status'
  Prelude.Int ->
  CreateFolderResponse
newCreateFolderResponse :: Int -> CreateFolderResponse
newCreateFolderResponse Int
pStatus_ =
  CreateFolderResponse'
    { $sel:arn:CreateFolderResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:folderId:CreateFolderResponse' :: Maybe Text
folderId = forall a. Maybe a
Prelude.Nothing,
      $sel:requestId:CreateFolderResponse' :: Maybe Text
requestId = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateFolderResponse' :: Int
status = Int
pStatus_
    }

-- | The Amazon Resource Name (ARN) for the newly created folder.
createFolderResponse_arn :: Lens.Lens' CreateFolderResponse (Prelude.Maybe Prelude.Text)
createFolderResponse_arn :: Lens' CreateFolderResponse (Maybe Text)
createFolderResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolderResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:CreateFolderResponse' :: CreateFolderResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: CreateFolderResponse
s@CreateFolderResponse' {} Maybe Text
a -> CreateFolderResponse
s {$sel:arn:CreateFolderResponse' :: Maybe Text
arn = Maybe Text
a} :: CreateFolderResponse)

-- | The folder ID for the newly created folder.
createFolderResponse_folderId :: Lens.Lens' CreateFolderResponse (Prelude.Maybe Prelude.Text)
createFolderResponse_folderId :: Lens' CreateFolderResponse (Maybe Text)
createFolderResponse_folderId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolderResponse' {Maybe Text
folderId :: Maybe Text
$sel:folderId:CreateFolderResponse' :: CreateFolderResponse -> Maybe Text
folderId} -> Maybe Text
folderId) (\s :: CreateFolderResponse
s@CreateFolderResponse' {} Maybe Text
a -> CreateFolderResponse
s {$sel:folderId:CreateFolderResponse' :: Maybe Text
folderId = Maybe Text
a} :: CreateFolderResponse)

-- | The request ID for the newly created folder.
createFolderResponse_requestId :: Lens.Lens' CreateFolderResponse (Prelude.Maybe Prelude.Text)
createFolderResponse_requestId :: Lens' CreateFolderResponse (Maybe Text)
createFolderResponse_requestId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolderResponse' {Maybe Text
requestId :: Maybe Text
$sel:requestId:CreateFolderResponse' :: CreateFolderResponse -> Maybe Text
requestId} -> Maybe Text
requestId) (\s :: CreateFolderResponse
s@CreateFolderResponse' {} Maybe Text
a -> CreateFolderResponse
s {$sel:requestId:CreateFolderResponse' :: Maybe Text
requestId = Maybe Text
a} :: CreateFolderResponse)

-- | The HTTP status of the request.
createFolderResponse_status :: Lens.Lens' CreateFolderResponse Prelude.Int
createFolderResponse_status :: Lens' CreateFolderResponse Int
createFolderResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFolderResponse' {Int
status :: Int
$sel:status:CreateFolderResponse' :: CreateFolderResponse -> Int
status} -> Int
status) (\s :: CreateFolderResponse
s@CreateFolderResponse' {} Int
a -> CreateFolderResponse
s {$sel:status:CreateFolderResponse' :: Int
status = Int
a} :: CreateFolderResponse)

instance Prelude.NFData CreateFolderResponse where
  rnf :: CreateFolderResponse -> ()
rnf CreateFolderResponse' {Int
Maybe Text
status :: Int
requestId :: Maybe Text
folderId :: Maybe Text
arn :: Maybe Text
$sel:status:CreateFolderResponse' :: CreateFolderResponse -> Int
$sel:requestId:CreateFolderResponse' :: CreateFolderResponse -> Maybe Text
$sel:folderId:CreateFolderResponse' :: CreateFolderResponse -> Maybe Text
$sel:arn:CreateFolderResponse' :: CreateFolderResponse -> Maybe Text
..} =
    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
folderId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
requestId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
status