FlowNodeConfiguration.h

 
#pragma once
#include <aws/bedrock-agent/BedrockAgent_EXPORTS.h>
#include <aws/bedrock-agent/model/AgentFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/CollectorFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/ConditionFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/InlineCodeFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/InputFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/IteratorFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/KnowledgeBaseFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/LambdaFunctionFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/LexFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/LoopControllerFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/LoopInputFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/OutputFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/PromptFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/RetrievalFlowNodeConfiguration.h>
#include <aws/bedrock-agent/model/StorageFlowNodeConfiguration.h>
#include <aws/core/utils/memory/stl/AWSAllocator.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockAgent {
namespace Model {
class LoopFlowNodeConfiguration;
 
class FlowNodeConfiguration {
 public:
  AWS_BEDROCKAGENT_API FlowNodeConfiguration() = default;
  AWS_BEDROCKAGENT_API FlowNodeConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENT_API FlowNodeConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const InputFlowNodeConfiguration& GetInput() const { return m_input; }
  inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
  template <typename InputT = InputFlowNodeConfiguration>
  void SetInput(InputT&& value) {
    m_inputHasBeenSet = true;
    m_input = std::forward<InputT>(value);
  }
  template <typename InputT = InputFlowNodeConfiguration>
  FlowNodeConfiguration& WithInput(InputT&& value) {
    SetInput(std::forward<InputT>(value));
    return *this;
  }
 
 
  inline const OutputFlowNodeConfiguration& GetOutput() const { return m_output; }
  inline bool OutputHasBeenSet() const { return m_outputHasBeenSet; }
  template <typename OutputT = OutputFlowNodeConfiguration>
  void SetOutput(OutputT&& value) {
    m_outputHasBeenSet = true;
    m_output = std::forward<OutputT>(value);
  }
  template <typename OutputT = OutputFlowNodeConfiguration>
  FlowNodeConfiguration& WithOutput(OutputT&& value) {
    SetOutput(std::forward<OutputT>(value));
    return *this;
  }
 
 
  inline const KnowledgeBaseFlowNodeConfiguration& GetKnowledgeBase() const { return m_knowledgeBase; }
  inline bool KnowledgeBaseHasBeenSet() const { return m_knowledgeBaseHasBeenSet; }
  template <typename KnowledgeBaseT = KnowledgeBaseFlowNodeConfiguration>
  void SetKnowledgeBase(KnowledgeBaseT&& value) {
    m_knowledgeBaseHasBeenSet = true;
    m_knowledgeBase = std::forward<KnowledgeBaseT>(value);
  }
  template <typename KnowledgeBaseT = KnowledgeBaseFlowNodeConfiguration>
  FlowNodeConfiguration& WithKnowledgeBase(KnowledgeBaseT&& value) {
    SetKnowledgeBase(std::forward<KnowledgeBaseT>(value));
    return *this;
  }
 
 
  inline const ConditionFlowNodeConfiguration& GetCondition() const { return m_condition; }
  inline bool ConditionHasBeenSet() const { return m_conditionHasBeenSet; }
  template <typename ConditionT = ConditionFlowNodeConfiguration>
  void SetCondition(ConditionT&& value) {
    m_conditionHasBeenSet = true;
    m_condition = std::forward<ConditionT>(value);
  }
  template <typename ConditionT = ConditionFlowNodeConfiguration>
  FlowNodeConfiguration& WithCondition(ConditionT&& value) {
    SetCondition(std::forward<ConditionT>(value));
    return *this;
  }
 
 
  inline const LexFlowNodeConfiguration& GetLex() const { return m_lex; }
  inline bool LexHasBeenSet() const { return m_lexHasBeenSet; }
  template <typename LexT = LexFlowNodeConfiguration>
  void SetLex(LexT&& value) {
    m_lexHasBeenSet = true;
    m_lex = std::forward<LexT>(value);
  }
  template <typename LexT = LexFlowNodeConfiguration>
  FlowNodeConfiguration& WithLex(LexT&& value) {
    SetLex(std::forward<LexT>(value));
    return *this;
  }
 
 
  inline const PromptFlowNodeConfiguration& GetPrompt() const { return m_prompt; }
  inline bool PromptHasBeenSet() const { return m_promptHasBeenSet; }
  template <typename PromptT = PromptFlowNodeConfiguration>
  void SetPrompt(PromptT&& value) {
    m_promptHasBeenSet = true;
    m_prompt = std::forward<PromptT>(value);
  }
  template <typename PromptT = PromptFlowNodeConfiguration>
  FlowNodeConfiguration& WithPrompt(PromptT&& value) {
    SetPrompt(std::forward<PromptT>(value));
    return *this;
  }
 
 
  inline const LambdaFunctionFlowNodeConfiguration& GetLambdaFunction() const { return m_lambdaFunction; }
  inline bool LambdaFunctionHasBeenSet() const { return m_lambdaFunctionHasBeenSet; }
  template <typename LambdaFunctionT = LambdaFunctionFlowNodeConfiguration>
  void SetLambdaFunction(LambdaFunctionT&& value) {
    m_lambdaFunctionHasBeenSet = true;
    m_lambdaFunction = std::forward<LambdaFunctionT>(value);
  }
  template <typename LambdaFunctionT = LambdaFunctionFlowNodeConfiguration>
  FlowNodeConfiguration& WithLambdaFunction(LambdaFunctionT&& value) {
    SetLambdaFunction(std::forward<LambdaFunctionT>(value));
    return *this;
  }
 
 
  inline const StorageFlowNodeConfiguration& GetStorage() const { return m_storage; }
  inline bool StorageHasBeenSet() const { return m_storageHasBeenSet; }
  template <typename StorageT = StorageFlowNodeConfiguration>
  void SetStorage(StorageT&& value) {
    m_storageHasBeenSet = true;
    m_storage = std::forward<StorageT>(value);
  }
  template <typename StorageT = StorageFlowNodeConfiguration>
  FlowNodeConfiguration& WithStorage(StorageT&& value) {
    SetStorage(std::forward<StorageT>(value));
    return *this;
  }
 
 
  inline const AgentFlowNodeConfiguration& GetAgent() const { return m_agent; }
  inline bool AgentHasBeenSet() const { return m_agentHasBeenSet; }
  template <typename AgentT = AgentFlowNodeConfiguration>
  void SetAgent(AgentT&& value) {
    m_agentHasBeenSet = true;
    m_agent = std::forward<AgentT>(value);
  }
  template <typename AgentT = AgentFlowNodeConfiguration>
  FlowNodeConfiguration& WithAgent(AgentT&& value) {
    SetAgent(std::forward<AgentT>(value));
    return *this;
  }
 
 
  inline const RetrievalFlowNodeConfiguration& GetRetrieval() const { return m_retrieval; }
  inline bool RetrievalHasBeenSet() const { return m_retrievalHasBeenSet; }
  template <typename RetrievalT = RetrievalFlowNodeConfiguration>
  void SetRetrieval(RetrievalT&& value) {
    m_retrievalHasBeenSet = true;
    m_retrieval = std::forward<RetrievalT>(value);
  }
  template <typename RetrievalT = RetrievalFlowNodeConfiguration>
  FlowNodeConfiguration& WithRetrieval(RetrievalT&& value) {
    SetRetrieval(std::forward<RetrievalT>(value));
    return *this;
  }
 
 
  inline const IteratorFlowNodeConfiguration& GetIterator() const { return m_iterator; }
  inline bool IteratorHasBeenSet() const { return m_iteratorHasBeenSet; }
  template <typename IteratorT = IteratorFlowNodeConfiguration>
  void SetIterator(IteratorT&& value) {
    m_iteratorHasBeenSet = true;
    m_iterator = std::forward<IteratorT>(value);
  }
  template <typename IteratorT = IteratorFlowNodeConfiguration>
  FlowNodeConfiguration& WithIterator(IteratorT&& value) {
    SetIterator(std::forward<IteratorT>(value));
    return *this;
  }
 
 
  inline const CollectorFlowNodeConfiguration& GetCollector() const { return m_collector; }
  inline bool CollectorHasBeenSet() const { return m_collectorHasBeenSet; }
  template <typename CollectorT = CollectorFlowNodeConfiguration>
  void SetCollector(CollectorT&& value) {
    m_collectorHasBeenSet = true;
    m_collector = std::forward<CollectorT>(value);
  }
  template <typename CollectorT = CollectorFlowNodeConfiguration>
  FlowNodeConfiguration& WithCollector(CollectorT&& value) {
    SetCollector(std::forward<CollectorT>(value));
    return *this;
  }
 
 
  inline const InlineCodeFlowNodeConfiguration& GetInlineCode() const { return m_inlineCode; }
  inline bool InlineCodeHasBeenSet() const { return m_inlineCodeHasBeenSet; }
  template <typename InlineCodeT = InlineCodeFlowNodeConfiguration>
  void SetInlineCode(InlineCodeT&& value) {
    m_inlineCodeHasBeenSet = true;
    m_inlineCode = std::forward<InlineCodeT>(value);
  }
  template <typename InlineCodeT = InlineCodeFlowNodeConfiguration>
  FlowNodeConfiguration& WithInlineCode(InlineCodeT&& value) {
    SetInlineCode(std::forward<InlineCodeT>(value));
    return *this;
  }
 
 
  inline const LoopFlowNodeConfiguration& GetLoop() const { return *m_loop; }
  inline bool LoopHasBeenSet() const { return m_loopHasBeenSet; }
  template <typename LoopT = LoopFlowNodeConfiguration>
  void SetLoop(LoopT&& value) {
    m_loopHasBeenSet = true;
    m_loop = Aws::MakeShared<LoopFlowNodeConfiguration>("FlowNodeConfiguration", std::forward<LoopT>(value));
  }
  template <typename LoopT = LoopFlowNodeConfiguration>
  FlowNodeConfiguration& WithLoop(LoopT&& value) {
    SetLoop(std::forward<LoopT>(value));
    return *this;
  }
 
 
  inline const LoopInputFlowNodeConfiguration& GetLoopInput() const { return m_loopInput; }
  inline bool LoopInputHasBeenSet() const { return m_loopInputHasBeenSet; }
  template <typename LoopInputT = LoopInputFlowNodeConfiguration>
  void SetLoopInput(LoopInputT&& value) {
    m_loopInputHasBeenSet = true;
    m_loopInput = std::forward<LoopInputT>(value);
  }
  template <typename LoopInputT = LoopInputFlowNodeConfiguration>
  FlowNodeConfiguration& WithLoopInput(LoopInputT&& value) {
    SetLoopInput(std::forward<LoopInputT>(value));
    return *this;
  }
 
 
  inline const LoopControllerFlowNodeConfiguration& GetLoopController() const { return m_loopController; }
  inline bool LoopControllerHasBeenSet() const { return m_loopControllerHasBeenSet; }
  template <typename LoopControllerT = LoopControllerFlowNodeConfiguration>
  void SetLoopController(LoopControllerT&& value) {
    m_loopControllerHasBeenSet = true;
    m_loopController = std::forward<LoopControllerT>(value);
  }
  template <typename LoopControllerT = LoopControllerFlowNodeConfiguration>
  FlowNodeConfiguration& WithLoopController(LoopControllerT&& value) {
    SetLoopController(std::forward<LoopControllerT>(value));
    return *this;
  }
 private:
  InputFlowNodeConfiguration m_input;
 
  OutputFlowNodeConfiguration m_output;
 
  KnowledgeBaseFlowNodeConfiguration m_knowledgeBase;
 
  ConditionFlowNodeConfiguration m_condition;
 
  LexFlowNodeConfiguration m_lex;
 
  PromptFlowNodeConfiguration m_prompt;
 
  LambdaFunctionFlowNodeConfiguration m_lambdaFunction;
 
  StorageFlowNodeConfiguration m_storage;
 
  AgentFlowNodeConfiguration m_agent;
 
  RetrievalFlowNodeConfiguration m_retrieval;
 
  IteratorFlowNodeConfiguration m_iterator;
 
  CollectorFlowNodeConfiguration m_collector;
 
  InlineCodeFlowNodeConfiguration m_inlineCode;
 
  std::shared_ptr<LoopFlowNodeConfiguration> m_loop;
 
  LoopInputFlowNodeConfiguration m_loopInput;
 
  LoopControllerFlowNodeConfiguration m_loopController;
  bool m_inputHasBeenSet = false;
  bool m_outputHasBeenSet = false;
  bool m_knowledgeBaseHasBeenSet = false;
  bool m_conditionHasBeenSet = false;
  bool m_lexHasBeenSet = false;
  bool m_promptHasBeenSet = false;
  bool m_lambdaFunctionHasBeenSet = false;
  bool m_storageHasBeenSet = false;
  bool m_agentHasBeenSet = false;
  bool m_retrievalHasBeenSet = false;
  bool m_iteratorHasBeenSet = false;
  bool m_collectorHasBeenSet = false;
  bool m_inlineCodeHasBeenSet = false;
  bool m_loopHasBeenSet = false;
  bool m_loopInputHasBeenSet = false;
  bool m_loopControllerHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockAgent
}  // namespace Aws