Handshake.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/organizations/Organizations_EXPORTS.h>
#include <aws/organizations/model/ActionType.h>
#include <aws/organizations/model/HandshakeParty.h>
#include <aws/organizations/model/HandshakeResource.h>
#include <aws/organizations/model/HandshakeState.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;
 
  Aws::String m_arn;
 
  Aws::Vector<HandshakeParty> m_parties;
 
  HandshakeState m_state{HandshakeState::NOT_SET};
 
  Aws::Utils::DateTime m_requestedTimestamp{};
 
  Aws::Utils::DateTime m_expirationTimestamp{};
 
  ActionType m_action{ActionType::NOT_SET};
 
  Aws::Vector<HandshakeResource> m_resources;
  bool m_idHasBeenSet = false;
  bool m_arnHasBeenSet = false;
  bool m_partiesHasBeenSet = false;
  bool m_stateHasBeenSet = false;
  bool m_requestedTimestampHasBeenSet = false;
  bool m_expirationTimestampHasBeenSet = false;
  bool m_actionHasBeenSet = false;
  bool m_resourcesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Organizations
}  // namespace Aws