{-# 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.CloudDirectory.CreateFacet
-- 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 a new Facet in a schema. Facet creation is allowed only in
-- development or applied schemas.
module Amazonka.CloudDirectory.CreateFacet
  ( -- * Creating a Request
    CreateFacet (..),
    newCreateFacet,

    -- * Request Lenses
    createFacet_attributes,
    createFacet_facetStyle,
    createFacet_objectType,
    createFacet_schemaArn,
    createFacet_name,

    -- * Destructuring the Response
    CreateFacetResponse (..),
    newCreateFacetResponse,

    -- * Response Lenses
    createFacetResponse_httpStatus,
  )
where

import Amazonka.CloudDirectory.Types
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 qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateFacet' smart constructor.
data CreateFacet = CreateFacet'
  { -- | The attributes that are associated with the Facet.
    CreateFacet -> Maybe [FacetAttribute]
attributes :: Prelude.Maybe [FacetAttribute],
    -- | There are two different styles that you can define on any given facet,
    -- @Static@ and @Dynamic@. For static facets, all attributes must be
    -- defined in the schema. For dynamic facets, attributes can be defined
    -- during data plane operations.
    CreateFacet -> Maybe FacetStyle
facetStyle :: Prelude.Maybe FacetStyle,
    -- | Specifies whether a given object created from this facet is of type
    -- node, leaf node, policy or index.
    --
    -- -   Node: Can have multiple children but one parent.
    --
    -- -   Leaf node: Cannot have children but can have multiple parents.
    --
    -- -   Policy: Allows you to store a policy document and policy type. For
    --     more information, see
    --     <https://docs.aws.amazon.com/clouddirectory/latest/developerguide/key_concepts_directory.html#key_concepts_policies Policies>.
    --
    -- -   Index: Can be created with the Index API.
    CreateFacet -> Maybe ObjectType
objectType :: Prelude.Maybe ObjectType,
    -- | The schema ARN in which the new Facet will be created. For more
    -- information, see arns.
    CreateFacet -> Text
schemaArn :: Prelude.Text,
    -- | The name of the Facet, which is unique for a given schema.
    CreateFacet -> Text
name :: Prelude.Text
  }
  deriving (CreateFacet -> CreateFacet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFacet -> CreateFacet -> Bool
$c/= :: CreateFacet -> CreateFacet -> Bool
== :: CreateFacet -> CreateFacet -> Bool
$c== :: CreateFacet -> CreateFacet -> Bool
Prelude.Eq, ReadPrec [CreateFacet]
ReadPrec CreateFacet
Int -> ReadS CreateFacet
ReadS [CreateFacet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateFacet]
$creadListPrec :: ReadPrec [CreateFacet]
readPrec :: ReadPrec CreateFacet
$creadPrec :: ReadPrec CreateFacet
readList :: ReadS [CreateFacet]
$creadList :: ReadS [CreateFacet]
readsPrec :: Int -> ReadS CreateFacet
$creadsPrec :: Int -> ReadS CreateFacet
Prelude.Read, Int -> CreateFacet -> ShowS
[CreateFacet] -> ShowS
CreateFacet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateFacet] -> ShowS
$cshowList :: [CreateFacet] -> ShowS
show :: CreateFacet -> String
$cshow :: CreateFacet -> String
showsPrec :: Int -> CreateFacet -> ShowS
$cshowsPrec :: Int -> CreateFacet -> ShowS
Prelude.Show, forall x. Rep CreateFacet x -> CreateFacet
forall x. CreateFacet -> Rep CreateFacet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateFacet x -> CreateFacet
$cfrom :: forall x. CreateFacet -> Rep CreateFacet x
Prelude.Generic)

-- |
-- Create a value of 'CreateFacet' 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:
--
-- 'attributes', 'createFacet_attributes' - The attributes that are associated with the Facet.
--
-- 'facetStyle', 'createFacet_facetStyle' - There are two different styles that you can define on any given facet,
-- @Static@ and @Dynamic@. For static facets, all attributes must be
-- defined in the schema. For dynamic facets, attributes can be defined
-- during data plane operations.
--
-- 'objectType', 'createFacet_objectType' - Specifies whether a given object created from this facet is of type
-- node, leaf node, policy or index.
--
-- -   Node: Can have multiple children but one parent.
--
-- -   Leaf node: Cannot have children but can have multiple parents.
--
-- -   Policy: Allows you to store a policy document and policy type. For
--     more information, see
--     <https://docs.aws.amazon.com/clouddirectory/latest/developerguide/key_concepts_directory.html#key_concepts_policies Policies>.
--
-- -   Index: Can be created with the Index API.
--
-- 'schemaArn', 'createFacet_schemaArn' - The schema ARN in which the new Facet will be created. For more
-- information, see arns.
--
-- 'name', 'createFacet_name' - The name of the Facet, which is unique for a given schema.
newCreateFacet ::
  -- | 'schemaArn'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  CreateFacet
newCreateFacet :: Text -> Text -> CreateFacet
newCreateFacet Text
pSchemaArn_ Text
pName_ =
  CreateFacet'
    { $sel:attributes:CreateFacet' :: Maybe [FacetAttribute]
attributes = forall a. Maybe a
Prelude.Nothing,
      $sel:facetStyle:CreateFacet' :: Maybe FacetStyle
facetStyle = forall a. Maybe a
Prelude.Nothing,
      $sel:objectType:CreateFacet' :: Maybe ObjectType
objectType = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaArn:CreateFacet' :: Text
schemaArn = Text
pSchemaArn_,
      $sel:name:CreateFacet' :: Text
name = Text
pName_
    }

-- | The attributes that are associated with the Facet.
createFacet_attributes :: Lens.Lens' CreateFacet (Prelude.Maybe [FacetAttribute])
createFacet_attributes :: Lens' CreateFacet (Maybe [FacetAttribute])
createFacet_attributes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFacet' {Maybe [FacetAttribute]
attributes :: Maybe [FacetAttribute]
$sel:attributes:CreateFacet' :: CreateFacet -> Maybe [FacetAttribute]
attributes} -> Maybe [FacetAttribute]
attributes) (\s :: CreateFacet
s@CreateFacet' {} Maybe [FacetAttribute]
a -> CreateFacet
s {$sel:attributes:CreateFacet' :: Maybe [FacetAttribute]
attributes = Maybe [FacetAttribute]
a} :: CreateFacet) 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

-- | There are two different styles that you can define on any given facet,
-- @Static@ and @Dynamic@. For static facets, all attributes must be
-- defined in the schema. For dynamic facets, attributes can be defined
-- during data plane operations.
createFacet_facetStyle :: Lens.Lens' CreateFacet (Prelude.Maybe FacetStyle)
createFacet_facetStyle :: Lens' CreateFacet (Maybe FacetStyle)
createFacet_facetStyle = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFacet' {Maybe FacetStyle
facetStyle :: Maybe FacetStyle
$sel:facetStyle:CreateFacet' :: CreateFacet -> Maybe FacetStyle
facetStyle} -> Maybe FacetStyle
facetStyle) (\s :: CreateFacet
s@CreateFacet' {} Maybe FacetStyle
a -> CreateFacet
s {$sel:facetStyle:CreateFacet' :: Maybe FacetStyle
facetStyle = Maybe FacetStyle
a} :: CreateFacet)

-- | Specifies whether a given object created from this facet is of type
-- node, leaf node, policy or index.
--
-- -   Node: Can have multiple children but one parent.
--
-- -   Leaf node: Cannot have children but can have multiple parents.
--
-- -   Policy: Allows you to store a policy document and policy type. For
--     more information, see
--     <https://docs.aws.amazon.com/clouddirectory/latest/developerguide/key_concepts_directory.html#key_concepts_policies Policies>.
--
-- -   Index: Can be created with the Index API.
createFacet_objectType :: Lens.Lens' CreateFacet (Prelude.Maybe ObjectType)
createFacet_objectType :: Lens' CreateFacet (Maybe ObjectType)
createFacet_objectType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFacet' {Maybe ObjectType
objectType :: Maybe ObjectType
$sel:objectType:CreateFacet' :: CreateFacet -> Maybe ObjectType
objectType} -> Maybe ObjectType
objectType) (\s :: CreateFacet
s@CreateFacet' {} Maybe ObjectType
a -> CreateFacet
s {$sel:objectType:CreateFacet' :: Maybe ObjectType
objectType = Maybe ObjectType
a} :: CreateFacet)

-- | The schema ARN in which the new Facet will be created. For more
-- information, see arns.
createFacet_schemaArn :: Lens.Lens' CreateFacet Prelude.Text
createFacet_schemaArn :: Lens' CreateFacet Text
createFacet_schemaArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFacet' {Text
schemaArn :: Text
$sel:schemaArn:CreateFacet' :: CreateFacet -> Text
schemaArn} -> Text
schemaArn) (\s :: CreateFacet
s@CreateFacet' {} Text
a -> CreateFacet
s {$sel:schemaArn:CreateFacet' :: Text
schemaArn = Text
a} :: CreateFacet)

-- | The name of the Facet, which is unique for a given schema.
createFacet_name :: Lens.Lens' CreateFacet Prelude.Text
createFacet_name :: Lens' CreateFacet Text
createFacet_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateFacet' {Text
name :: Text
$sel:name:CreateFacet' :: CreateFacet -> Text
name} -> Text
name) (\s :: CreateFacet
s@CreateFacet' {} Text
a -> CreateFacet
s {$sel:name:CreateFacet' :: Text
name = Text
a} :: CreateFacet)

instance Core.AWSRequest CreateFacet where
  type AWSResponse CreateFacet = CreateFacetResponse
  request :: (Service -> Service) -> CreateFacet -> Request CreateFacet
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.putJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateFacet
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateFacet)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> CreateFacetResponse
CreateFacetResponse'
            forall (f :: * -> *) a b. Functor 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 CreateFacet where
  hashWithSalt :: Int -> CreateFacet -> Int
hashWithSalt Int
_salt CreateFacet' {Maybe [FacetAttribute]
Maybe FacetStyle
Maybe ObjectType
Text
name :: Text
schemaArn :: Text
objectType :: Maybe ObjectType
facetStyle :: Maybe FacetStyle
attributes :: Maybe [FacetAttribute]
$sel:name:CreateFacet' :: CreateFacet -> Text
$sel:schemaArn:CreateFacet' :: CreateFacet -> Text
$sel:objectType:CreateFacet' :: CreateFacet -> Maybe ObjectType
$sel:facetStyle:CreateFacet' :: CreateFacet -> Maybe FacetStyle
$sel:attributes:CreateFacet' :: CreateFacet -> Maybe [FacetAttribute]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [FacetAttribute]
attributes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FacetStyle
facetStyle
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ObjectType
objectType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
schemaArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateFacet where
  rnf :: CreateFacet -> ()
rnf CreateFacet' {Maybe [FacetAttribute]
Maybe FacetStyle
Maybe ObjectType
Text
name :: Text
schemaArn :: Text
objectType :: Maybe ObjectType
facetStyle :: Maybe FacetStyle
attributes :: Maybe [FacetAttribute]
$sel:name:CreateFacet' :: CreateFacet -> Text
$sel:schemaArn:CreateFacet' :: CreateFacet -> Text
$sel:objectType:CreateFacet' :: CreateFacet -> Maybe ObjectType
$sel:facetStyle:CreateFacet' :: CreateFacet -> Maybe FacetStyle
$sel:attributes:CreateFacet' :: CreateFacet -> Maybe [FacetAttribute]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [FacetAttribute]
attributes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FacetStyle
facetStyle
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ObjectType
objectType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
schemaArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name

instance Data.ToHeaders CreateFacet where
  toHeaders :: CreateFacet -> ResponseHeaders
toHeaders CreateFacet' {Maybe [FacetAttribute]
Maybe FacetStyle
Maybe ObjectType
Text
name :: Text
schemaArn :: Text
objectType :: Maybe ObjectType
facetStyle :: Maybe FacetStyle
attributes :: Maybe [FacetAttribute]
$sel:name:CreateFacet' :: CreateFacet -> Text
$sel:schemaArn:CreateFacet' :: CreateFacet -> Text
$sel:objectType:CreateFacet' :: CreateFacet -> Maybe ObjectType
$sel:facetStyle:CreateFacet' :: CreateFacet -> Maybe FacetStyle
$sel:attributes:CreateFacet' :: CreateFacet -> Maybe [FacetAttribute]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [HeaderName
"x-amz-data-partition" forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Text
schemaArn]

instance Data.ToJSON CreateFacet where
  toJSON :: CreateFacet -> Value
toJSON CreateFacet' {Maybe [FacetAttribute]
Maybe FacetStyle
Maybe ObjectType
Text
name :: Text
schemaArn :: Text
objectType :: Maybe ObjectType
facetStyle :: Maybe FacetStyle
attributes :: Maybe [FacetAttribute]
$sel:name:CreateFacet' :: CreateFacet -> Text
$sel:schemaArn:CreateFacet' :: CreateFacet -> Text
$sel:objectType:CreateFacet' :: CreateFacet -> Maybe ObjectType
$sel:facetStyle:CreateFacet' :: CreateFacet -> Maybe FacetStyle
$sel:attributes:CreateFacet' :: CreateFacet -> Maybe [FacetAttribute]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Attributes" 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 [FacetAttribute]
attributes,
            (Key
"FacetStyle" 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 FacetStyle
facetStyle,
            (Key
"ObjectType" 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 ObjectType
objectType,
            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 CreateFacet where
  toPath :: CreateFacet -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const
      ByteString
"/amazonclouddirectory/2017-01-11/facet/create"

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

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

-- |
-- Create a value of 'CreateFacetResponse' 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:
--
-- 'httpStatus', 'createFacetResponse_httpStatus' - The response's http status code.
newCreateFacetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateFacetResponse
newCreateFacetResponse :: Int -> CreateFacetResponse
newCreateFacetResponse Int
pHttpStatus_ =
  CreateFacetResponse' {$sel:httpStatus:CreateFacetResponse' :: Int
httpStatus = Int
pHttpStatus_}

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

instance Prelude.NFData CreateFacetResponse where
  rnf :: CreateFacetResponse -> ()
rnf CreateFacetResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateFacetResponse' :: CreateFacetResponse -> Int
..} = forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus