{-# 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.Outposts.UpdateSiteAddress
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates the address of the specified site.
--
-- You can\'t update a site address if there is an order in progress. You
-- must wait for the order to complete or cancel the order.
--
-- You can update the operating address before you place an order at the
-- site, or after all Outposts that belong to the site have been
-- deactivated.
module Amazonka.Outposts.UpdateSiteAddress
  ( -- * Creating a Request
    UpdateSiteAddress (..),
    newUpdateSiteAddress,

    -- * Request Lenses
    updateSiteAddress_siteId,
    updateSiteAddress_addressType,
    updateSiteAddress_address,

    -- * Destructuring the Response
    UpdateSiteAddressResponse (..),
    newUpdateSiteAddressResponse,

    -- * Response Lenses
    updateSiteAddressResponse_address,
    updateSiteAddressResponse_addressType,
    updateSiteAddressResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateSiteAddress' smart constructor.
data UpdateSiteAddress = UpdateSiteAddress'
  { -- | The ID or the Amazon Resource Name (ARN) of the site.
    UpdateSiteAddress -> Text
siteId :: Prelude.Text,
    -- | The type of the address.
    UpdateSiteAddress -> AddressType
addressType :: AddressType,
    -- | The address for the site.
    UpdateSiteAddress -> Address
address :: Address
  }
  deriving (UpdateSiteAddress -> UpdateSiteAddress -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateSiteAddress -> UpdateSiteAddress -> Bool
$c/= :: UpdateSiteAddress -> UpdateSiteAddress -> Bool
== :: UpdateSiteAddress -> UpdateSiteAddress -> Bool
$c== :: UpdateSiteAddress -> UpdateSiteAddress -> Bool
Prelude.Eq, ReadPrec [UpdateSiteAddress]
ReadPrec UpdateSiteAddress
Int -> ReadS UpdateSiteAddress
ReadS [UpdateSiteAddress]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateSiteAddress]
$creadListPrec :: ReadPrec [UpdateSiteAddress]
readPrec :: ReadPrec UpdateSiteAddress
$creadPrec :: ReadPrec UpdateSiteAddress
readList :: ReadS [UpdateSiteAddress]
$creadList :: ReadS [UpdateSiteAddress]
readsPrec :: Int -> ReadS UpdateSiteAddress
$creadsPrec :: Int -> ReadS UpdateSiteAddress
Prelude.Read, Int -> UpdateSiteAddress -> ShowS
[UpdateSiteAddress] -> ShowS
UpdateSiteAddress -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateSiteAddress] -> ShowS
$cshowList :: [UpdateSiteAddress] -> ShowS
show :: UpdateSiteAddress -> String
$cshow :: UpdateSiteAddress -> String
showsPrec :: Int -> UpdateSiteAddress -> ShowS
$cshowsPrec :: Int -> UpdateSiteAddress -> ShowS
Prelude.Show, forall x. Rep UpdateSiteAddress x -> UpdateSiteAddress
forall x. UpdateSiteAddress -> Rep UpdateSiteAddress x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateSiteAddress x -> UpdateSiteAddress
$cfrom :: forall x. UpdateSiteAddress -> Rep UpdateSiteAddress x
Prelude.Generic)

-- |
-- Create a value of 'UpdateSiteAddress' 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:
--
-- 'siteId', 'updateSiteAddress_siteId' - The ID or the Amazon Resource Name (ARN) of the site.
--
-- 'addressType', 'updateSiteAddress_addressType' - The type of the address.
--
-- 'address', 'updateSiteAddress_address' - The address for the site.
newUpdateSiteAddress ::
  -- | 'siteId'
  Prelude.Text ->
  -- | 'addressType'
  AddressType ->
  -- | 'address'
  Address ->
  UpdateSiteAddress
newUpdateSiteAddress :: Text -> AddressType -> Address -> UpdateSiteAddress
newUpdateSiteAddress Text
pSiteId_ AddressType
pAddressType_ Address
pAddress_ =
  UpdateSiteAddress'
    { $sel:siteId:UpdateSiteAddress' :: Text
siteId = Text
pSiteId_,
      $sel:addressType:UpdateSiteAddress' :: AddressType
addressType = AddressType
pAddressType_,
      $sel:address:UpdateSiteAddress' :: Address
address = Address
pAddress_
    }

-- | The ID or the Amazon Resource Name (ARN) of the site.
updateSiteAddress_siteId :: Lens.Lens' UpdateSiteAddress Prelude.Text
updateSiteAddress_siteId :: Lens' UpdateSiteAddress Text
updateSiteAddress_siteId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSiteAddress' {Text
siteId :: Text
$sel:siteId:UpdateSiteAddress' :: UpdateSiteAddress -> Text
siteId} -> Text
siteId) (\s :: UpdateSiteAddress
s@UpdateSiteAddress' {} Text
a -> UpdateSiteAddress
s {$sel:siteId:UpdateSiteAddress' :: Text
siteId = Text
a} :: UpdateSiteAddress)

-- | The type of the address.
updateSiteAddress_addressType :: Lens.Lens' UpdateSiteAddress AddressType
updateSiteAddress_addressType :: Lens' UpdateSiteAddress AddressType
updateSiteAddress_addressType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSiteAddress' {AddressType
addressType :: AddressType
$sel:addressType:UpdateSiteAddress' :: UpdateSiteAddress -> AddressType
addressType} -> AddressType
addressType) (\s :: UpdateSiteAddress
s@UpdateSiteAddress' {} AddressType
a -> UpdateSiteAddress
s {$sel:addressType:UpdateSiteAddress' :: AddressType
addressType = AddressType
a} :: UpdateSiteAddress)

-- | The address for the site.
updateSiteAddress_address :: Lens.Lens' UpdateSiteAddress Address
updateSiteAddress_address :: Lens' UpdateSiteAddress Address
updateSiteAddress_address = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSiteAddress' {Address
address :: Address
$sel:address:UpdateSiteAddress' :: UpdateSiteAddress -> Address
address} -> Address
address) (\s :: UpdateSiteAddress
s@UpdateSiteAddress' {} Address
a -> UpdateSiteAddress
s {$sel:address:UpdateSiteAddress' :: Address
address = Address
a} :: UpdateSiteAddress)

instance Core.AWSRequest UpdateSiteAddress where
  type
    AWSResponse UpdateSiteAddress =
      UpdateSiteAddressResponse
  request :: (Service -> Service)
-> UpdateSiteAddress -> Request UpdateSiteAddress
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 UpdateSiteAddress
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateSiteAddress)))
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 Address
-> Maybe AddressType -> Int -> UpdateSiteAddressResponse
UpdateSiteAddressResponse'
            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
"Address")
            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
"AddressType")
            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 UpdateSiteAddress where
  hashWithSalt :: Int -> UpdateSiteAddress -> Int
hashWithSalt Int
_salt UpdateSiteAddress' {Text
Address
AddressType
address :: Address
addressType :: AddressType
siteId :: Text
$sel:address:UpdateSiteAddress' :: UpdateSiteAddress -> Address
$sel:addressType:UpdateSiteAddress' :: UpdateSiteAddress -> AddressType
$sel:siteId:UpdateSiteAddress' :: UpdateSiteAddress -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
siteId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` AddressType
addressType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Address
address

instance Prelude.NFData UpdateSiteAddress where
  rnf :: UpdateSiteAddress -> ()
rnf UpdateSiteAddress' {Text
Address
AddressType
address :: Address
addressType :: AddressType
siteId :: Text
$sel:address:UpdateSiteAddress' :: UpdateSiteAddress -> Address
$sel:addressType:UpdateSiteAddress' :: UpdateSiteAddress -> AddressType
$sel:siteId:UpdateSiteAddress' :: UpdateSiteAddress -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
siteId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf AddressType
addressType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Address
address

instance Data.ToHeaders UpdateSiteAddress where
  toHeaders :: UpdateSiteAddress -> 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 UpdateSiteAddress where
  toJSON :: UpdateSiteAddress -> Value
toJSON UpdateSiteAddress' {Text
Address
AddressType
address :: Address
addressType :: AddressType
siteId :: Text
$sel:address:UpdateSiteAddress' :: UpdateSiteAddress -> Address
$sel:addressType:UpdateSiteAddress' :: UpdateSiteAddress -> AddressType
$sel:siteId:UpdateSiteAddress' :: UpdateSiteAddress -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"AddressType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= AddressType
addressType),
            forall a. a -> Maybe a
Prelude.Just (Key
"Address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Address
address)
          ]
      )

instance Data.ToPath UpdateSiteAddress where
  toPath :: UpdateSiteAddress -> ByteString
toPath UpdateSiteAddress' {Text
Address
AddressType
address :: Address
addressType :: AddressType
siteId :: Text
$sel:address:UpdateSiteAddress' :: UpdateSiteAddress -> Address
$sel:addressType:UpdateSiteAddress' :: UpdateSiteAddress -> AddressType
$sel:siteId:UpdateSiteAddress' :: UpdateSiteAddress -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/sites/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
siteId, ByteString
"/address"]

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

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

-- |
-- Create a value of 'UpdateSiteAddressResponse' 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:
--
-- 'address', 'updateSiteAddressResponse_address' - Information about an address.
--
-- 'addressType', 'updateSiteAddressResponse_addressType' - The type of the address.
--
-- 'httpStatus', 'updateSiteAddressResponse_httpStatus' - The response's http status code.
newUpdateSiteAddressResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateSiteAddressResponse
newUpdateSiteAddressResponse :: Int -> UpdateSiteAddressResponse
newUpdateSiteAddressResponse Int
pHttpStatus_ =
  UpdateSiteAddressResponse'
    { $sel:address:UpdateSiteAddressResponse' :: Maybe Address
address =
        forall a. Maybe a
Prelude.Nothing,
      $sel:addressType:UpdateSiteAddressResponse' :: Maybe AddressType
addressType = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateSiteAddressResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about an address.
updateSiteAddressResponse_address :: Lens.Lens' UpdateSiteAddressResponse (Prelude.Maybe Address)
updateSiteAddressResponse_address :: Lens' UpdateSiteAddressResponse (Maybe Address)
updateSiteAddressResponse_address = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSiteAddressResponse' {Maybe Address
address :: Maybe Address
$sel:address:UpdateSiteAddressResponse' :: UpdateSiteAddressResponse -> Maybe Address
address} -> Maybe Address
address) (\s :: UpdateSiteAddressResponse
s@UpdateSiteAddressResponse' {} Maybe Address
a -> UpdateSiteAddressResponse
s {$sel:address:UpdateSiteAddressResponse' :: Maybe Address
address = Maybe Address
a} :: UpdateSiteAddressResponse)

-- | The type of the address.
updateSiteAddressResponse_addressType :: Lens.Lens' UpdateSiteAddressResponse (Prelude.Maybe AddressType)
updateSiteAddressResponse_addressType :: Lens' UpdateSiteAddressResponse (Maybe AddressType)
updateSiteAddressResponse_addressType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSiteAddressResponse' {Maybe AddressType
addressType :: Maybe AddressType
$sel:addressType:UpdateSiteAddressResponse' :: UpdateSiteAddressResponse -> Maybe AddressType
addressType} -> Maybe AddressType
addressType) (\s :: UpdateSiteAddressResponse
s@UpdateSiteAddressResponse' {} Maybe AddressType
a -> UpdateSiteAddressResponse
s {$sel:addressType:UpdateSiteAddressResponse' :: Maybe AddressType
addressType = Maybe AddressType
a} :: UpdateSiteAddressResponse)

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

instance Prelude.NFData UpdateSiteAddressResponse where
  rnf :: UpdateSiteAddressResponse -> ()
rnf UpdateSiteAddressResponse' {Int
Maybe Address
Maybe AddressType
httpStatus :: Int
addressType :: Maybe AddressType
address :: Maybe Address
$sel:httpStatus:UpdateSiteAddressResponse' :: UpdateSiteAddressResponse -> Int
$sel:addressType:UpdateSiteAddressResponse' :: UpdateSiteAddressResponse -> Maybe AddressType
$sel:address:UpdateSiteAddressResponse' :: UpdateSiteAddressResponse -> Maybe Address
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Address
address
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AddressType
addressType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus