{-# 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.SSM.StartAssociationsOnce
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Runs an association immediately and only one time. This operation can be
-- helpful when troubleshooting associations.
module Amazonka.SSM.StartAssociationsOnce
  ( -- * Creating a Request
    StartAssociationsOnce (..),
    newStartAssociationsOnce,

    -- * Request Lenses
    startAssociationsOnce_associationIds,

    -- * Destructuring the Response
    StartAssociationsOnceResponse (..),
    newStartAssociationsOnceResponse,

    -- * Response Lenses
    startAssociationsOnceResponse_httpStatus,
  )
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 qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SSM.Types

-- | /See:/ 'newStartAssociationsOnce' smart constructor.
data StartAssociationsOnce = StartAssociationsOnce'
  { -- | The association IDs that you want to run immediately and only one time.
    StartAssociationsOnce -> NonEmpty Text
associationIds :: Prelude.NonEmpty Prelude.Text
  }
  deriving (StartAssociationsOnce -> StartAssociationsOnce -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartAssociationsOnce -> StartAssociationsOnce -> Bool
$c/= :: StartAssociationsOnce -> StartAssociationsOnce -> Bool
== :: StartAssociationsOnce -> StartAssociationsOnce -> Bool
$c== :: StartAssociationsOnce -> StartAssociationsOnce -> Bool
Prelude.Eq, ReadPrec [StartAssociationsOnce]
ReadPrec StartAssociationsOnce
Int -> ReadS StartAssociationsOnce
ReadS [StartAssociationsOnce]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartAssociationsOnce]
$creadListPrec :: ReadPrec [StartAssociationsOnce]
readPrec :: ReadPrec StartAssociationsOnce
$creadPrec :: ReadPrec StartAssociationsOnce
readList :: ReadS [StartAssociationsOnce]
$creadList :: ReadS [StartAssociationsOnce]
readsPrec :: Int -> ReadS StartAssociationsOnce
$creadsPrec :: Int -> ReadS StartAssociationsOnce
Prelude.Read, Int -> StartAssociationsOnce -> ShowS
[StartAssociationsOnce] -> ShowS
StartAssociationsOnce -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartAssociationsOnce] -> ShowS
$cshowList :: [StartAssociationsOnce] -> ShowS
show :: StartAssociationsOnce -> String
$cshow :: StartAssociationsOnce -> String
showsPrec :: Int -> StartAssociationsOnce -> ShowS
$cshowsPrec :: Int -> StartAssociationsOnce -> ShowS
Prelude.Show, forall x. Rep StartAssociationsOnce x -> StartAssociationsOnce
forall x. StartAssociationsOnce -> Rep StartAssociationsOnce x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartAssociationsOnce x -> StartAssociationsOnce
$cfrom :: forall x. StartAssociationsOnce -> Rep StartAssociationsOnce x
Prelude.Generic)

-- |
-- Create a value of 'StartAssociationsOnce' 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:
--
-- 'associationIds', 'startAssociationsOnce_associationIds' - The association IDs that you want to run immediately and only one time.
newStartAssociationsOnce ::
  -- | 'associationIds'
  Prelude.NonEmpty Prelude.Text ->
  StartAssociationsOnce
newStartAssociationsOnce :: NonEmpty Text -> StartAssociationsOnce
newStartAssociationsOnce NonEmpty Text
pAssociationIds_ =
  StartAssociationsOnce'
    { $sel:associationIds:StartAssociationsOnce' :: NonEmpty Text
associationIds =
        forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Text
pAssociationIds_
    }

-- | The association IDs that you want to run immediately and only one time.
startAssociationsOnce_associationIds :: Lens.Lens' StartAssociationsOnce (Prelude.NonEmpty Prelude.Text)
startAssociationsOnce_associationIds :: Lens' StartAssociationsOnce (NonEmpty Text)
startAssociationsOnce_associationIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartAssociationsOnce' {NonEmpty Text
associationIds :: NonEmpty Text
$sel:associationIds:StartAssociationsOnce' :: StartAssociationsOnce -> NonEmpty Text
associationIds} -> NonEmpty Text
associationIds) (\s :: StartAssociationsOnce
s@StartAssociationsOnce' {} NonEmpty Text
a -> StartAssociationsOnce
s {$sel:associationIds:StartAssociationsOnce' :: NonEmpty Text
associationIds = NonEmpty Text
a} :: StartAssociationsOnce) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest StartAssociationsOnce where
  type
    AWSResponse StartAssociationsOnce =
      StartAssociationsOnceResponse
  request :: (Service -> Service)
-> StartAssociationsOnce -> Request StartAssociationsOnce
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 StartAssociationsOnce
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse StartAssociationsOnce)))
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 -> StartAssociationsOnceResponse
StartAssociationsOnceResponse'
            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 StartAssociationsOnce where
  hashWithSalt :: Int -> StartAssociationsOnce -> Int
hashWithSalt Int
_salt StartAssociationsOnce' {NonEmpty Text
associationIds :: NonEmpty Text
$sel:associationIds:StartAssociationsOnce' :: StartAssociationsOnce -> NonEmpty Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
associationIds

instance Prelude.NFData StartAssociationsOnce where
  rnf :: StartAssociationsOnce -> ()
rnf StartAssociationsOnce' {NonEmpty Text
associationIds :: NonEmpty Text
$sel:associationIds:StartAssociationsOnce' :: StartAssociationsOnce -> NonEmpty Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
associationIds

instance Data.ToHeaders StartAssociationsOnce where
  toHeaders :: StartAssociationsOnce -> 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
"AmazonSSM.StartAssociationsOnce" ::
                          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 StartAssociationsOnce where
  toJSON :: StartAssociationsOnce -> Value
toJSON StartAssociationsOnce' {NonEmpty Text
associationIds :: NonEmpty Text
$sel:associationIds:StartAssociationsOnce' :: StartAssociationsOnce -> NonEmpty Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just
              (Key
"AssociationIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
associationIds)
          ]
      )

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

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

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

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

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

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