FlowExecutionEvent.h

 
#pragma once
#include <aws/bedrock-agent-runtime/BedrockAgentRuntime_EXPORTS.h>
#include <aws/bedrock-agent-runtime/model/ConditionResultEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowExecutionInputEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowExecutionOutputEvent.h>
#include <aws/bedrock-agent-runtime/model/FlowFailureEvent.h>
#include <aws/bedrock-agent-runtime/model/NodeActionEvent.h>
#include <aws/bedrock-agent-runtime/model/NodeDependencyEvent.h>
#include <aws/bedrock-agent-runtime/model/NodeFailureEvent.h>
#include <aws/bedrock-agent-runtime/model/NodeInputEvent.h>
#include <aws/bedrock-agent-runtime/model/NodeOutputEvent.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockAgentRuntime {
namespace Model {
 
class FlowExecutionEvent {
 public:
  AWS_BEDROCKAGENTRUNTIME_API FlowExecutionEvent() = default;
  AWS_BEDROCKAGENTRUNTIME_API FlowExecutionEvent(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API FlowExecutionEvent& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const ConditionResultEvent& GetConditionResultEvent() const { return m_conditionResultEvent; }
  inline bool ConditionResultEventHasBeenSet() const { return m_conditionResultEventHasBeenSet; }
  template <typename ConditionResultEventT = ConditionResultEvent>
  void SetConditionResultEvent(ConditionResultEventT&& value) {
    m_conditionResultEventHasBeenSet = true;
    m_conditionResultEvent = std::forward<ConditionResultEventT>(value);
  }
  template <typename ConditionResultEventT = ConditionResultEvent>
  FlowExecutionEvent& WithConditionResultEvent(ConditionResultEventT&& value) {
    SetConditionResultEvent(std::forward<ConditionResultEventT>(value));
    return *this;
  }
 
 
  inline const FlowFailureEvent& GetFlowFailureEvent() const { return m_flowFailureEvent; }
  inline bool FlowFailureEventHasBeenSet() const { return m_flowFailureEventHasBeenSet; }
  template <typename FlowFailureEventT = FlowFailureEvent>
  void SetFlowFailureEvent(FlowFailureEventT&& value) {
    m_flowFailureEventHasBeenSet = true;
    m_flowFailureEvent = std::forward<FlowFailureEventT>(value);
  }
  template <typename FlowFailureEventT = FlowFailureEvent>
  FlowExecutionEvent& WithFlowFailureEvent(FlowFailureEventT&& value) {
    SetFlowFailureEvent(std::forward<FlowFailureEventT>(value));
    return *this;
  }
 
 
  inline const FlowExecutionInputEvent& GetFlowInputEvent() const { return m_flowInputEvent; }
  inline bool FlowInputEventHasBeenSet() const { return m_flowInputEventHasBeenSet; }
  template <typename FlowInputEventT = FlowExecutionInputEvent>
  void SetFlowInputEvent(FlowInputEventT&& value) {
    m_flowInputEventHasBeenSet = true;
    m_flowInputEvent = std::forward<FlowInputEventT>(value);
  }
  template <typename FlowInputEventT = FlowExecutionInputEvent>
  FlowExecutionEvent& WithFlowInputEvent(FlowInputEventT&& value) {
    SetFlowInputEvent(std::forward<FlowInputEventT>(value));
    return *this;
  }
 
 
  inline const FlowExecutionOutputEvent& GetFlowOutputEvent() const { return m_flowOutputEvent; }
  inline bool FlowOutputEventHasBeenSet() const { return m_flowOutputEventHasBeenSet; }
  template <typename FlowOutputEventT = FlowExecutionOutputEvent>
  void SetFlowOutputEvent(FlowOutputEventT&& value) {
    m_flowOutputEventHasBeenSet = true;
    m_flowOutputEvent = std::forward<FlowOutputEventT>(value);
  }
  template <typename FlowOutputEventT = FlowExecutionOutputEvent>
  FlowExecutionEvent& WithFlowOutputEvent(FlowOutputEventT&& value) {
    SetFlowOutputEvent(std::forward<FlowOutputEventT>(value));
    return *this;
  }
 
 
  inline const NodeActionEvent& GetNodeActionEvent() const { return m_nodeActionEvent; }
  inline bool NodeActionEventHasBeenSet() const { return m_nodeActionEventHasBeenSet; }
  template <typename NodeActionEventT = NodeActionEvent>
  void SetNodeActionEvent(NodeActionEventT&& value) {
    m_nodeActionEventHasBeenSet = true;
    m_nodeActionEvent = std::forward<NodeActionEventT>(value);
  }
  template <typename NodeActionEventT = NodeActionEvent>
  FlowExecutionEvent& WithNodeActionEvent(NodeActionEventT&& value) {
    SetNodeActionEvent(std::forward<NodeActionEventT>(value));
    return *this;
  }
 
 
  inline const NodeDependencyEvent& GetNodeDependencyEvent() const { return m_nodeDependencyEvent; }
  inline bool NodeDependencyEventHasBeenSet() const { return m_nodeDependencyEventHasBeenSet; }
  template <typename NodeDependencyEventT = NodeDependencyEvent>
  void SetNodeDependencyEvent(NodeDependencyEventT&& value) {
    m_nodeDependencyEventHasBeenSet = true;
    m_nodeDependencyEvent = std::forward<NodeDependencyEventT>(value);
  }
  template <typename NodeDependencyEventT = NodeDependencyEvent>
  FlowExecutionEvent& WithNodeDependencyEvent(NodeDependencyEventT&& value) {
    SetNodeDependencyEvent(std::forward<NodeDependencyEventT>(value));
    return *this;
  }
 
 
  inline const NodeFailureEvent& GetNodeFailureEvent() const { return m_nodeFailureEvent; }
  inline bool NodeFailureEventHasBeenSet() const { return m_nodeFailureEventHasBeenSet; }
  template <typename NodeFailureEventT = NodeFailureEvent>
  void SetNodeFailureEvent(NodeFailureEventT&& value) {
    m_nodeFailureEventHasBeenSet = true;
    m_nodeFailureEvent = std::forward<NodeFailureEventT>(value);
  }
  template <typename NodeFailureEventT = NodeFailureEvent>
  FlowExecutionEvent& WithNodeFailureEvent(NodeFailureEventT&& value) {
    SetNodeFailureEvent(std::forward<NodeFailureEventT>(value));
    return *this;
  }
 
 
  inline const NodeInputEvent& GetNodeInputEvent() const { return m_nodeInputEvent; }
  inline bool NodeInputEventHasBeenSet() const { return m_nodeInputEventHasBeenSet; }
  template <typename NodeInputEventT = NodeInputEvent>
  void SetNodeInputEvent(NodeInputEventT&& value) {
    m_nodeInputEventHasBeenSet = true;
    m_nodeInputEvent = std::forward<NodeInputEventT>(value);
  }
  template <typename NodeInputEventT = NodeInputEvent>
  FlowExecutionEvent& WithNodeInputEvent(NodeInputEventT&& value) {
    SetNodeInputEvent(std::forward<NodeInputEventT>(value));
    return *this;
  }
 
 
  inline const NodeOutputEvent& GetNodeOutputEvent() const { return m_nodeOutputEvent; }
  inline bool NodeOutputEventHasBeenSet() const { return m_nodeOutputEventHasBeenSet; }
  template <typename NodeOutputEventT = NodeOutputEvent>
  void SetNodeOutputEvent(NodeOutputEventT&& value) {
    m_nodeOutputEventHasBeenSet = true;
    m_nodeOutputEvent = std::forward<NodeOutputEventT>(value);
  }
  template <typename NodeOutputEventT = NodeOutputEvent>
  FlowExecutionEvent& WithNodeOutputEvent(NodeOutputEventT&& value) {
    SetNodeOutputEvent(std::forward<NodeOutputEventT>(value));
    return *this;
  }
 private:
  ConditionResultEvent m_conditionResultEvent;
 
  FlowFailureEvent m_flowFailureEvent;
 
  FlowExecutionInputEvent m_flowInputEvent;
 
  FlowExecutionOutputEvent m_flowOutputEvent;
 
  NodeActionEvent m_nodeActionEvent;
 
  NodeDependencyEvent m_nodeDependencyEvent;
 
  NodeFailureEvent m_nodeFailureEvent;
 
  NodeInputEvent m_nodeInputEvent;
 
  NodeOutputEvent m_nodeOutputEvent;
  bool m_conditionResultEventHasBeenSet = false;
  bool m_flowFailureEventHasBeenSet = false;
  bool m_flowInputEventHasBeenSet = false;
  bool m_flowOutputEventHasBeenSet = false;
  bool m_nodeActionEventHasBeenSet = false;
  bool m_nodeDependencyEventHasBeenSet = false;
  bool m_nodeFailureEventHasBeenSet = false;
  bool m_nodeInputEventHasBeenSet = false;
  bool m_nodeOutputEventHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockAgentRuntime
}  // namespace Aws