Trace.h

 
#pragma once
#include <aws/bedrock-agent-runtime/BedrockAgentRuntime_EXPORTS.h>
#include <aws/bedrock-agent-runtime/model/CustomOrchestrationTrace.h>
#include <aws/bedrock-agent-runtime/model/FailureTrace.h>
#include <aws/bedrock-agent-runtime/model/GuardrailTrace.h>
#include <aws/bedrock-agent-runtime/model/OrchestrationTrace.h>
#include <aws/bedrock-agent-runtime/model/PostProcessingTrace.h>
#include <aws/bedrock-agent-runtime/model/PreProcessingTrace.h>
#include <aws/bedrock-agent-runtime/model/RoutingClassifierTrace.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockAgentRuntime {
namespace Model {
 
class Trace {
 public:
  AWS_BEDROCKAGENTRUNTIME_API Trace() = default;
  AWS_BEDROCKAGENTRUNTIME_API Trace(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API Trace& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const CustomOrchestrationTrace& GetCustomOrchestrationTrace() const { return m_customOrchestrationTrace; }
  inline bool CustomOrchestrationTraceHasBeenSet() const { return m_customOrchestrationTraceHasBeenSet; }
  template <typename CustomOrchestrationTraceT = CustomOrchestrationTrace>
  void SetCustomOrchestrationTrace(CustomOrchestrationTraceT&& value) {
    m_customOrchestrationTraceHasBeenSet = true;
    m_customOrchestrationTrace = std::forward<CustomOrchestrationTraceT>(value);
  }
  template <typename CustomOrchestrationTraceT = CustomOrchestrationTrace>
  Trace& WithCustomOrchestrationTrace(CustomOrchestrationTraceT&& value) {
    SetCustomOrchestrationTrace(std::forward<CustomOrchestrationTraceT>(value));
    return *this;
  }
 
 
  inline const FailureTrace& GetFailureTrace() const { return m_failureTrace; }
  inline bool FailureTraceHasBeenSet() const { return m_failureTraceHasBeenSet; }
  template <typename FailureTraceT = FailureTrace>
  void SetFailureTrace(FailureTraceT&& value) {
    m_failureTraceHasBeenSet = true;
    m_failureTrace = std::forward<FailureTraceT>(value);
  }
  template <typename FailureTraceT = FailureTrace>
  Trace& WithFailureTrace(FailureTraceT&& value) {
    SetFailureTrace(std::forward<FailureTraceT>(value));
    return *this;
  }
 
 
  inline const GuardrailTrace& GetGuardrailTrace() const { return m_guardrailTrace; }
  inline bool GuardrailTraceHasBeenSet() const { return m_guardrailTraceHasBeenSet; }
  template <typename GuardrailTraceT = GuardrailTrace>
  void SetGuardrailTrace(GuardrailTraceT&& value) {
    m_guardrailTraceHasBeenSet = true;
    m_guardrailTrace = std::forward<GuardrailTraceT>(value);
  }
  template <typename GuardrailTraceT = GuardrailTrace>
  Trace& WithGuardrailTrace(GuardrailTraceT&& value) {
    SetGuardrailTrace(std::forward<GuardrailTraceT>(value));
    return *this;
  }
 
 
  inline const OrchestrationTrace& GetOrchestrationTrace() const { return m_orchestrationTrace; }
  inline bool OrchestrationTraceHasBeenSet() const { return m_orchestrationTraceHasBeenSet; }
  template <typename OrchestrationTraceT = OrchestrationTrace>
  void SetOrchestrationTrace(OrchestrationTraceT&& value) {
    m_orchestrationTraceHasBeenSet = true;
    m_orchestrationTrace = std::forward<OrchestrationTraceT>(value);
  }
  template <typename OrchestrationTraceT = OrchestrationTrace>
  Trace& WithOrchestrationTrace(OrchestrationTraceT&& value) {
    SetOrchestrationTrace(std::forward<OrchestrationTraceT>(value));
    return *this;
  }
 
 
  inline const PostProcessingTrace& GetPostProcessingTrace() const { return m_postProcessingTrace; }
  inline bool PostProcessingTraceHasBeenSet() const { return m_postProcessingTraceHasBeenSet; }
  template <typename PostProcessingTraceT = PostProcessingTrace>
  void SetPostProcessingTrace(PostProcessingTraceT&& value) {
    m_postProcessingTraceHasBeenSet = true;
    m_postProcessingTrace = std::forward<PostProcessingTraceT>(value);
  }
  template <typename PostProcessingTraceT = PostProcessingTrace>
  Trace& WithPostProcessingTrace(PostProcessingTraceT&& value) {
    SetPostProcessingTrace(std::forward<PostProcessingTraceT>(value));
    return *this;
  }
 
 
  inline const PreProcessingTrace& GetPreProcessingTrace() const { return m_preProcessingTrace; }
  inline bool PreProcessingTraceHasBeenSet() const { return m_preProcessingTraceHasBeenSet; }
  template <typename PreProcessingTraceT = PreProcessingTrace>
  void SetPreProcessingTrace(PreProcessingTraceT&& value) {
    m_preProcessingTraceHasBeenSet = true;
    m_preProcessingTrace = std::forward<PreProcessingTraceT>(value);
  }
  template <typename PreProcessingTraceT = PreProcessingTrace>
  Trace& WithPreProcessingTrace(PreProcessingTraceT&& value) {
    SetPreProcessingTrace(std::forward<PreProcessingTraceT>(value));
    return *this;
  }
 
 
  inline const RoutingClassifierTrace& GetRoutingClassifierTrace() const { return m_routingClassifierTrace; }
  inline bool RoutingClassifierTraceHasBeenSet() const { return m_routingClassifierTraceHasBeenSet; }
  template <typename RoutingClassifierTraceT = RoutingClassifierTrace>
  void SetRoutingClassifierTrace(RoutingClassifierTraceT&& value) {
    m_routingClassifierTraceHasBeenSet = true;
    m_routingClassifierTrace = std::forward<RoutingClassifierTraceT>(value);
  }
  template <typename RoutingClassifierTraceT = RoutingClassifierTrace>
  Trace& WithRoutingClassifierTrace(RoutingClassifierTraceT&& value) {
    SetRoutingClassifierTrace(std::forward<RoutingClassifierTraceT>(value));
    return *this;
  }
 private:
  CustomOrchestrationTrace m_customOrchestrationTrace;
 
  FailureTrace m_failureTrace;
 
  GuardrailTrace m_guardrailTrace;
 
  OrchestrationTrace m_orchestrationTrace;
 
  PostProcessingTrace m_postProcessingTrace;
 
  PreProcessingTrace m_preProcessingTrace;
 
  RoutingClassifierTrace m_routingClassifierTrace;
  bool m_customOrchestrationTraceHasBeenSet = false;
  bool m_failureTraceHasBeenSet = false;
  bool m_guardrailTraceHasBeenSet = false;
  bool m_orchestrationTraceHasBeenSet = false;
  bool m_postProcessingTraceHasBeenSet = false;
  bool m_preProcessingTraceHasBeenSet = false;
  bool m_routingClassifierTraceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockAgentRuntime
}  // namespace Aws