JournalRecord.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/Document.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/devops-agent/DevOpsAgent_EXPORTS.h>
#include <aws/devops-agent/model/UserReference.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DevOpsAgent {
namespace Model {
 
class JournalRecord {
 public:
  AWS_DEVOPSAGENT_API JournalRecord() = default;
  AWS_DEVOPSAGENT_API JournalRecord(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEVOPSAGENT_API JournalRecord& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEVOPSAGENT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAgentSpaceId() const { return m_agentSpaceId; }
  inline bool AgentSpaceIdHasBeenSet() const { return m_agentSpaceIdHasBeenSet; }
  template <typename AgentSpaceIdT = Aws::String>
  void SetAgentSpaceId(AgentSpaceIdT&& value) {
    m_agentSpaceIdHasBeenSet = true;
    m_agentSpaceId = std::forward<AgentSpaceIdT>(value);
  }
  template <typename AgentSpaceIdT = Aws::String>
  JournalRecord& WithAgentSpaceId(AgentSpaceIdT&& value) {
    SetAgentSpaceId(std::forward<AgentSpaceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionId() const { return m_executionId; }
  inline bool ExecutionIdHasBeenSet() const { return m_executionIdHasBeenSet; }
  template <typename ExecutionIdT = Aws::String>
  void SetExecutionId(ExecutionIdT&& value) {
    m_executionIdHasBeenSet = true;
    m_executionId = std::forward<ExecutionIdT>(value);
  }
  template <typename ExecutionIdT = Aws::String>
  JournalRecord& WithExecutionId(ExecutionIdT&& value) {
    SetExecutionId(std::forward<ExecutionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRecordId() const { return m_recordId; }
  inline bool RecordIdHasBeenSet() const { return m_recordIdHasBeenSet; }
  template <typename RecordIdT = Aws::String>
  void SetRecordId(RecordIdT&& value) {
    m_recordIdHasBeenSet = true;
    m_recordId = std::forward<RecordIdT>(value);
  }
  template <typename RecordIdT = Aws::String>
  JournalRecord& WithRecordId(RecordIdT&& value) {
    SetRecordId(std::forward<RecordIdT>(value));
    return *this;
  }
 
 
  inline Aws::Utils::DocumentView GetContent() const { return m_content; }
  inline bool ContentHasBeenSet() const { return m_contentHasBeenSet; }
  template <typename ContentT = Aws::Utils::Document>
  void SetContent(ContentT&& value) {
    m_contentHasBeenSet = true;
    m_content = std::forward<ContentT>(value);
  }
  template <typename ContentT = Aws::Utils::Document>
  JournalRecord& WithContent(ContentT&& value) {
    SetContent(std::forward<ContentT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  JournalRecord& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRecordType() const { return m_recordType; }
  inline bool RecordTypeHasBeenSet() const { return m_recordTypeHasBeenSet; }
  template <typename RecordTypeT = Aws::String>
  void SetRecordType(RecordTypeT&& value) {
    m_recordTypeHasBeenSet = true;
    m_recordType = std::forward<RecordTypeT>(value);
  }
  template <typename RecordTypeT = Aws::String>
  JournalRecord& WithRecordType(RecordTypeT&& value) {
    SetRecordType(std::forward<RecordTypeT>(value));
    return *this;
  }
 
 
  inline const UserReference& GetUserReference() const { return m_userReference; }
  inline bool UserReferenceHasBeenSet() const { return m_userReferenceHasBeenSet; }
  template <typename UserReferenceT = UserReference>
  void SetUserReference(UserReferenceT&& value) {
    m_userReferenceHasBeenSet = true;
    m_userReference = std::forward<UserReferenceT>(value);
  }
  template <typename UserReferenceT = UserReference>
  JournalRecord& WithUserReference(UserReferenceT&& value) {
    SetUserReference(std::forward<UserReferenceT>(value));
    return *this;
  }
 private:
  Aws::String m_agentSpaceId;
 
  Aws::String m_executionId;
 
  Aws::String m_recordId;
 
  Aws::Utils::Document m_content;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::String m_recordType;
 
  UserReference m_userReference;
  bool m_agentSpaceIdHasBeenSet = false;
  bool m_executionIdHasBeenSet = false;
  bool m_recordIdHasBeenSet = false;
  bool m_contentHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_recordTypeHasBeenSet = false;
  bool m_userReferenceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DevOpsAgent
}  // namespace Aws