Handshake.h

 
#pragma once
#include <aws/organizations/Organizations_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/organizations/model/HandshakeState.h>
#include <aws/core/utils/DateTime.h>
#include <aws/organizations/model/ActionType.h>
#include <aws/organizations/model/HandshakeParty.h>
#include <aws/organizations/model/HandshakeResource.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Organizations
{
namespace Model
{
 
  class Handshake
  {
  public:
    AWS_ORGANIZATIONS_API Handshake() = default;
    AWS_ORGANIZATIONS_API Handshake(Aws::Utils::Json::JsonView jsonValue);
    AWS_ORGANIZATIONS_API Handshake& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_ORGANIZATIONS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetId() const { return m_id; }
    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
    template<typename IdT = Aws::String>
    void SetId(IdT&& value) { m_idHasBeenSet = true; m_id = std::forward<IdT>(value); }
    template<typename IdT = Aws::String>
    Handshake& WithId(IdT&& value) { SetId(std::forward<IdT>(value)); return *this;}
 
 
    inline const Aws::String& GetArn() const { return m_arn; }
    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
    template<typename ArnT = Aws::String>
    void SetArn(ArnT&& value) { m_arnHasBeenSet = true; m_arn = std::forward<ArnT>(value); }
    template<typename ArnT = Aws::String>
    Handshake& WithArn(ArnT&& value) { SetArn(std::forward<ArnT>(value)); return *this;}
 
 
    inline const Aws::Vector<HandshakeParty>& GetParties() const { return m_parties; }
    inline bool PartiesHasBeenSet() const { return m_partiesHasBeenSet; }
    template<typename PartiesT = Aws::Vector<HandshakeParty>>
    void SetParties(PartiesT&& value) { m_partiesHasBeenSet = true; m_parties = std::forward<PartiesT>(value); }
    template<typename PartiesT = Aws::Vector<HandshakeParty>>
    Handshake& WithParties(PartiesT&& value) { SetParties(std::forward<PartiesT>(value)); return *this;}
    template<typename PartiesT = HandshakeParty>
    Handshake& AddParties(PartiesT&& value) { m_partiesHasBeenSet = true; m_parties.emplace_back(std::forward<PartiesT>(value)); return *this; }
 
 
    inline HandshakeState GetState() const { return m_state; }
    inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
    inline void SetState(HandshakeState value) { m_stateHasBeenSet = true; m_state = value; }
    inline Handshake& WithState(HandshakeState value) { SetState(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetRequestedTimestamp() const { return m_requestedTimestamp; }
    inline bool RequestedTimestampHasBeenSet() const { return m_requestedTimestampHasBeenSet; }
    template<typename RequestedTimestampT = Aws::Utils::DateTime>
    void SetRequestedTimestamp(RequestedTimestampT&& value) { m_requestedTimestampHasBeenSet = true; m_requestedTimestamp = std::forward<RequestedTimestampT>(value); }
    template<typename RequestedTimestampT = Aws::Utils::DateTime>
    Handshake& WithRequestedTimestamp(RequestedTimestampT&& value) { SetRequestedTimestamp(std::forward<RequestedTimestampT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetExpirationTimestamp() const { return m_expirationTimestamp; }
    inline bool ExpirationTimestampHasBeenSet() const { return m_expirationTimestampHasBeenSet; }
    template<typename ExpirationTimestampT = Aws::Utils::DateTime>
    void SetExpirationTimestamp(ExpirationTimestampT&& value) { m_expirationTimestampHasBeenSet = true; m_expirationTimestamp = std::forward<ExpirationTimestampT>(value); }
    template<typename ExpirationTimestampT = Aws::Utils::DateTime>
    Handshake& WithExpirationTimestamp(ExpirationTimestampT&& value) { SetExpirationTimestamp(std::forward<ExpirationTimestampT>(value)); return *this;}
 
 
    inline ActionType GetAction() const { return m_action; }
    inline bool ActionHasBeenSet() const { return m_actionHasBeenSet; }
    inline void SetAction(ActionType value) { m_actionHasBeenSet = true; m_action = value; }
    inline Handshake& WithAction(ActionType value) { SetAction(value); return *this;}
 
 
    inline const Aws::Vector<HandshakeResource>& GetResources() const { return m_resources; }
    inline bool ResourcesHasBeenSet() const { return m_resourcesHasBeenSet; }
    template<typename ResourcesT = Aws::Vector<HandshakeResource>>
    void SetResources(ResourcesT&& value) { m_resourcesHasBeenSet = true; m_resources = std::forward<ResourcesT>(value); }
    template<typename ResourcesT = Aws::Vector<HandshakeResource>>
    Handshake& WithResources(ResourcesT&& value) { SetResources(std::forward<ResourcesT>(value)); return *this;}
    template<typename ResourcesT = HandshakeResource>
    Handshake& AddResources(ResourcesT&& value) { m_resourcesHasBeenSet = true; m_resources.emplace_back(std::forward<ResourcesT>(value)); return *this; }
  private:
 
    Aws::String m_id;
    bool m_idHasBeenSet = false;
 
    Aws::String m_arn;
    bool m_arnHasBeenSet = false;
 
    Aws::Vector<HandshakeParty> m_parties;
    bool m_partiesHasBeenSet = false;
 
    HandshakeState m_state{HandshakeState::NOT_SET};
    bool m_stateHasBeenSet = false;
 
    Aws::Utils::DateTime m_requestedTimestamp{};
    bool m_requestedTimestampHasBeenSet = false;
 
    Aws::Utils::DateTime m_expirationTimestamp{};
    bool m_expirationTimestampHasBeenSet = false;
 
    ActionType m_action{ActionType::NOT_SET};
    bool m_actionHasBeenSet = false;
 
    Aws::Vector<HandshakeResource> m_resources;
    bool m_resourcesHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Organizations
} // namespace Aws