AgentCollaborator.h

 
#pragma once
#include <aws/bedrock-agent/BedrockAgent_EXPORTS.h>
#include <aws/bedrock-agent/model/AgentDescriptor.h>
#include <aws/bedrock-agent/model/RelayConversationHistory.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockAgent {
namespace Model {
 
class AgentCollaborator {
 public:
  AWS_BEDROCKAGENT_API AgentCollaborator() = default;
  AWS_BEDROCKAGENT_API AgentCollaborator(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENT_API AgentCollaborator& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAgentId() const { return m_agentId; }
  inline bool AgentIdHasBeenSet() const { return m_agentIdHasBeenSet; }
  template <typename AgentIdT = Aws::String>
  void SetAgentId(AgentIdT&& value) {
    m_agentIdHasBeenSet = true;
    m_agentId = std::forward<AgentIdT>(value);
  }
  template <typename AgentIdT = Aws::String>
  AgentCollaborator& WithAgentId(AgentIdT&& value) {
    SetAgentId(std::forward<AgentIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAgentVersion() const { return m_agentVersion; }
  inline bool AgentVersionHasBeenSet() const { return m_agentVersionHasBeenSet; }
  template <typename AgentVersionT = Aws::String>
  void SetAgentVersion(AgentVersionT&& value) {
    m_agentVersionHasBeenSet = true;
    m_agentVersion = std::forward<AgentVersionT>(value);
  }
  template <typename AgentVersionT = Aws::String>
  AgentCollaborator& WithAgentVersion(AgentVersionT&& value) {
    SetAgentVersion(std::forward<AgentVersionT>(value));
    return *this;
  }
 
 
  inline const AgentDescriptor& GetAgentDescriptor() const { return m_agentDescriptor; }
  inline bool AgentDescriptorHasBeenSet() const { return m_agentDescriptorHasBeenSet; }
  template <typename AgentDescriptorT = AgentDescriptor>
  void SetAgentDescriptor(AgentDescriptorT&& value) {
    m_agentDescriptorHasBeenSet = true;
    m_agentDescriptor = std::forward<AgentDescriptorT>(value);
  }
  template <typename AgentDescriptorT = AgentDescriptor>
  AgentCollaborator& WithAgentDescriptor(AgentDescriptorT&& value) {
    SetAgentDescriptor(std::forward<AgentDescriptorT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCollaboratorId() const { return m_collaboratorId; }
  inline bool CollaboratorIdHasBeenSet() const { return m_collaboratorIdHasBeenSet; }
  template <typename CollaboratorIdT = Aws::String>
  void SetCollaboratorId(CollaboratorIdT&& value) {
    m_collaboratorIdHasBeenSet = true;
    m_collaboratorId = std::forward<CollaboratorIdT>(value);
  }
  template <typename CollaboratorIdT = Aws::String>
  AgentCollaborator& WithCollaboratorId(CollaboratorIdT&& value) {
    SetCollaboratorId(std::forward<CollaboratorIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCollaborationInstruction() const { return m_collaborationInstruction; }
  inline bool CollaborationInstructionHasBeenSet() const { return m_collaborationInstructionHasBeenSet; }
  template <typename CollaborationInstructionT = Aws::String>
  void SetCollaborationInstruction(CollaborationInstructionT&& value) {
    m_collaborationInstructionHasBeenSet = true;
    m_collaborationInstruction = std::forward<CollaborationInstructionT>(value);
  }
  template <typename CollaborationInstructionT = Aws::String>
  AgentCollaborator& WithCollaborationInstruction(CollaborationInstructionT&& value) {
    SetCollaborationInstruction(std::forward<CollaborationInstructionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCollaboratorName() const { return m_collaboratorName; }
  inline bool CollaboratorNameHasBeenSet() const { return m_collaboratorNameHasBeenSet; }
  template <typename CollaboratorNameT = Aws::String>
  void SetCollaboratorName(CollaboratorNameT&& value) {
    m_collaboratorNameHasBeenSet = true;
    m_collaboratorName = std::forward<CollaboratorNameT>(value);
  }
  template <typename CollaboratorNameT = Aws::String>
  AgentCollaborator& WithCollaboratorName(CollaboratorNameT&& value) {
    SetCollaboratorName(std::forward<CollaboratorNameT>(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>
  AgentCollaborator& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastUpdatedAt() const { return m_lastUpdatedAt; }
  inline bool LastUpdatedAtHasBeenSet() const { return m_lastUpdatedAtHasBeenSet; }
  template <typename LastUpdatedAtT = Aws::Utils::DateTime>
  void SetLastUpdatedAt(LastUpdatedAtT&& value) {
    m_lastUpdatedAtHasBeenSet = true;
    m_lastUpdatedAt = std::forward<LastUpdatedAtT>(value);
  }
  template <typename LastUpdatedAtT = Aws::Utils::DateTime>
  AgentCollaborator& WithLastUpdatedAt(LastUpdatedAtT&& value) {
    SetLastUpdatedAt(std::forward<LastUpdatedAtT>(value));
    return *this;
  }
 
 
  inline RelayConversationHistory GetRelayConversationHistory() const { return m_relayConversationHistory; }
  inline bool RelayConversationHistoryHasBeenSet() const { return m_relayConversationHistoryHasBeenSet; }
  inline void SetRelayConversationHistory(RelayConversationHistory value) {
    m_relayConversationHistoryHasBeenSet = true;
    m_relayConversationHistory = value;
  }
  inline AgentCollaborator& WithRelayConversationHistory(RelayConversationHistory value) {
    SetRelayConversationHistory(value);
    return *this;
  }
 
 
  inline const Aws::String& GetClientToken() const { return m_clientToken; }
  inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
  template <typename ClientTokenT = Aws::String>
  void SetClientToken(ClientTokenT&& value) {
    m_clientTokenHasBeenSet = true;
    m_clientToken = std::forward<ClientTokenT>(value);
  }
  template <typename ClientTokenT = Aws::String>
  AgentCollaborator& WithClientToken(ClientTokenT&& value) {
    SetClientToken(std::forward<ClientTokenT>(value));
    return *this;
  }
 private:
  Aws::String m_agentId;
  bool m_agentIdHasBeenSet = false;
 
  Aws::String m_agentVersion;
  bool m_agentVersionHasBeenSet = false;
 
  AgentDescriptor m_agentDescriptor;
  bool m_agentDescriptorHasBeenSet = false;
 
  Aws::String m_collaboratorId;
  bool m_collaboratorIdHasBeenSet = false;
 
  Aws::String m_collaborationInstruction;
  bool m_collaborationInstructionHasBeenSet = false;
 
  Aws::String m_collaboratorName;
  bool m_collaboratorNameHasBeenSet = false;
 
  Aws::Utils::DateTime m_createdAt{};
  bool m_createdAtHasBeenSet = false;
 
  Aws::Utils::DateTime m_lastUpdatedAt{};
  bool m_lastUpdatedAtHasBeenSet = false;
 
  RelayConversationHistory m_relayConversationHistory{RelayConversationHistory::NOT_SET};
  bool m_relayConversationHistoryHasBeenSet = false;
 
  Aws::String m_clientToken;
  bool m_clientTokenHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockAgent
}  // namespace Aws