FlowTrace.h

 
#pragma once
#include <aws/bedrock-agent-runtime/BedrockAgentRuntime_EXPORTS.h>
#include <aws/bedrock-agent-runtime/model/FlowTraceConditionNodeResultEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowTraceDependencyEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowTraceNodeActionEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowTraceNodeInputEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowTraceNodeOutputEvent.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockAgentRuntime {
namespace Model {
 
class FlowTrace {
 public:
  AWS_BEDROCKAGENTRUNTIME_API FlowTrace() = default;
  AWS_BEDROCKAGENTRUNTIME_API FlowTrace(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API FlowTrace& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const FlowTraceConditionNodeResultEvent& GetConditionNodeResultTrace() const { return m_conditionNodeResultTrace; }
  inline bool ConditionNodeResultTraceHasBeenSet() const { return m_conditionNodeResultTraceHasBeenSet; }
  template <typename ConditionNodeResultTraceT = FlowTraceConditionNodeResultEvent>
  void SetConditionNodeResultTrace(ConditionNodeResultTraceT&& value) {
    m_conditionNodeResultTraceHasBeenSet = true;
    m_conditionNodeResultTrace = std::forward<ConditionNodeResultTraceT>(value);
  }
  template <typename ConditionNodeResultTraceT = FlowTraceConditionNodeResultEvent>
  FlowTrace& WithConditionNodeResultTrace(ConditionNodeResultTraceT&& value) {
    SetConditionNodeResultTrace(std::forward<ConditionNodeResultTraceT>(value));
    return *this;
  }
 
 
  inline const FlowTraceNodeActionEvent& GetNodeActionTrace() const { return m_nodeActionTrace; }
  inline bool NodeActionTraceHasBeenSet() const { return m_nodeActionTraceHasBeenSet; }
  template <typename NodeActionTraceT = FlowTraceNodeActionEvent>
  void SetNodeActionTrace(NodeActionTraceT&& value) {
    m_nodeActionTraceHasBeenSet = true;
    m_nodeActionTrace = std::forward<NodeActionTraceT>(value);
  }
  template <typename NodeActionTraceT = FlowTraceNodeActionEvent>
  FlowTrace& WithNodeActionTrace(NodeActionTraceT&& value) {
    SetNodeActionTrace(std::forward<NodeActionTraceT>(value));
    return *this;
  }
 
 
  inline const FlowTraceDependencyEvent& GetNodeDependencyTrace() const { return m_nodeDependencyTrace; }
  inline bool NodeDependencyTraceHasBeenSet() const { return m_nodeDependencyTraceHasBeenSet; }
  template <typename NodeDependencyTraceT = FlowTraceDependencyEvent>
  void SetNodeDependencyTrace(NodeDependencyTraceT&& value) {
    m_nodeDependencyTraceHasBeenSet = true;
    m_nodeDependencyTrace = std::forward<NodeDependencyTraceT>(value);
  }
  template <typename NodeDependencyTraceT = FlowTraceDependencyEvent>
  FlowTrace& WithNodeDependencyTrace(NodeDependencyTraceT&& value) {
    SetNodeDependencyTrace(std::forward<NodeDependencyTraceT>(value));
    return *this;
  }
 
 
  inline const FlowTraceNodeInputEvent& GetNodeInputTrace() const { return m_nodeInputTrace; }
  inline bool NodeInputTraceHasBeenSet() const { return m_nodeInputTraceHasBeenSet; }
  template <typename NodeInputTraceT = FlowTraceNodeInputEvent>
  void SetNodeInputTrace(NodeInputTraceT&& value) {
    m_nodeInputTraceHasBeenSet = true;
    m_nodeInputTrace = std::forward<NodeInputTraceT>(value);
  }
  template <typename NodeInputTraceT = FlowTraceNodeInputEvent>
  FlowTrace& WithNodeInputTrace(NodeInputTraceT&& value) {
    SetNodeInputTrace(std::forward<NodeInputTraceT>(value));
    return *this;
  }
 
 
  inline const FlowTraceNodeOutputEvent& GetNodeOutputTrace() const { return m_nodeOutputTrace; }
  inline bool NodeOutputTraceHasBeenSet() const { return m_nodeOutputTraceHasBeenSet; }
  template <typename NodeOutputTraceT = FlowTraceNodeOutputEvent>
  void SetNodeOutputTrace(NodeOutputTraceT&& value) {
    m_nodeOutputTraceHasBeenSet = true;
    m_nodeOutputTrace = std::forward<NodeOutputTraceT>(value);
  }
  template <typename NodeOutputTraceT = FlowTraceNodeOutputEvent>
  FlowTrace& WithNodeOutputTrace(NodeOutputTraceT&& value) {
    SetNodeOutputTrace(std::forward<NodeOutputTraceT>(value));
    return *this;
  }
 private:
  FlowTraceConditionNodeResultEvent m_conditionNodeResultTrace;
 
  FlowTraceNodeActionEvent m_nodeActionTrace;
 
  FlowTraceDependencyEvent m_nodeDependencyTrace;
 
  FlowTraceNodeInputEvent m_nodeInputTrace;
 
  FlowTraceNodeOutputEvent m_nodeOutputTrace;
  bool m_conditionNodeResultTraceHasBeenSet = false;
  bool m_nodeActionTraceHasBeenSet = false;
  bool m_nodeDependencyTraceHasBeenSet = false;
  bool m_nodeInputTraceHasBeenSet = false;
  bool m_nodeOutputTraceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockAgentRuntime
}  // namespace Aws