Module: Aws::BedrockAgent::Types

Defined in:: lib/aws-sdk-bedrockagent/types.rb

Defined Under Namespace

Instance Attribute Summary collapse

#agent ⇒ Types::PromptAgentResource

Specifies an Amazon Bedrock agent with which to use the prompt.
#any ⇒ Types::AnyToolChoice

Defines tools, at least one of which must be requested by the model.
#auto ⇒ Types::AutoToolChoice

Defines tools.
#cache_point ⇒ Types::CachePointBlock

Creates a cache checkpoint within a tool designation.
#chat ⇒ Types::ChatPromptTemplateConfiguration

Contains configurations to use the prompt in a conversational format.
#collector ⇒ Types::CollectorFlowNodeConfiguration

Contains configurations for a collector node in your flow.
#condition ⇒ Types::ConditionFlowNodeConfiguration

Contains configurations for a condition node in your flow.
#conditional ⇒ Types::FlowConditionalConnectionConfiguration

The configuration of a connection originating from a Condition node.
#custom_control ⇒ String

To return the action group invocation results directly in the ‘InvokeAgent` response, specify `RETURN_CONTROL`.
#cyclic_connection ⇒ Types::CyclicConnectionFlowValidationDetails

Details about a cyclic connection in the flow.
#data ⇒ Types::FlowDataConnectionConfiguration

The configuration of a connection originating from a node that isn’t a Condition node.
#duplicate_condition_expression ⇒ Types::DuplicateConditionExpressionFlowValidationDetails

Details about duplicate condition expressions in a node.
#duplicate_connections ⇒ Types::DuplicateConnectionsFlowValidationDetails

Details about duplicate connections between nodes.
#fields_to_exclude ⇒ Array<Types::FieldForReranking>

Specifies the metadata fields to exclude from the reranking process.
#fields_to_include ⇒ Array<Types::FieldForReranking>

Specifies the metadata fields to include in the reranking process.
#functions ⇒ Array<Types::Function>

A list of functions that each define an action in the action group.
#incompatible_connection_data_type ⇒ Types::IncompatibleConnectionDataTypeFlowValidationDetails

Details about incompatible data types in a connection.
#inline ⇒ Types::PromptFlowNodeInlineConfiguration

Contains configurations for a prompt that is defined inline.
#inline_code ⇒ Types::InlineCodeFlowNodeConfiguration

Contains configurations for an inline code node in your flow.
#input ⇒ Types::InputFlowNodeConfiguration

Contains configurations for an input flow node in your flow.
#invalid_loop_boundary ⇒ Types::InvalidLoopBoundaryFlowValidationDetails

Details about a flow that includes connections that violate loop boundary rules.
#iterator ⇒ Types::IteratorFlowNodeConfiguration

Contains configurations for an iterator node in your flow.
#json ⇒ Hash, ...

A JSON object defining the input schema for the tool.
#knowledge_base ⇒ Types::KnowledgeBaseFlowNodeConfiguration

Contains configurations for a knowledge base node in your flow.
#lambda ⇒ String

The Amazon Resource Name (ARN) of the Lambda function containing the business logic that is carried out upon invoking the action.
#lambda_function ⇒ Types::LambdaFunctionFlowNodeConfiguration

Contains configurations for a Lambda function node in your flow.
#lex ⇒ Types::LexFlowNodeConfiguration

Contains configurations for a Lex node in your flow.
#loop ⇒ Types::LoopFlowNodeConfiguration

Contains configurations for a DoWhile loop in your flow.
#loop_controller ⇒ Types::LoopControllerFlowNodeConfiguration

Contains controller node configurations for a DoWhile loop in your flow.
#loop_incompatible_node_type ⇒ Types::LoopIncompatibleNodeTypeFlowValidationDetails

Details about a flow that includes incompatible node types in a DoWhile loop.
#loop_input ⇒ Types::LoopInputFlowNodeConfiguration

Contains input node configurations for a DoWhile loop in your flow.
#malformed_condition_expression ⇒ Types::MalformedConditionExpressionFlowValidationDetails

Details about a malformed condition expression in a node.
#malformed_node_input_expression ⇒ Types::MalformedNodeInputExpressionFlowValidationDetails

Details about a malformed input expression in a node.
#mismatched_node_input_type ⇒ Types::MismatchedNodeInputTypeFlowValidationDetails

Details about mismatched input data types in a node.
#mismatched_node_output_type ⇒ Types::MismatchedNodeOutputTypeFlowValidationDetails

Details about mismatched output data types in a node.
#missing_connection_configuration ⇒ Types::MissingConnectionConfigurationFlowValidationDetails

Details about missing configuration for a connection.
#missing_default_condition ⇒ Types::MissingDefaultConditionFlowValidationDetails

Details about a missing default condition in a conditional node.
#missing_ending_nodes ⇒ Types::MissingEndingNodesFlowValidationDetails

Details about missing ending nodes in the flow.
#missing_loop_controller_node ⇒ Types::MissingLoopControllerNodeFlowValidationDetails

Details about a flow that’s missing a required ‘LoopController` node in a DoWhile loop.
#missing_loop_input_node ⇒ Types::MissingLoopInputNodeFlowValidationDetails

Details about a flow that’s missing a required ‘LoopInput` node in a DoWhile loop.
#missing_node_configuration ⇒ Types::MissingNodeConfigurationFlowValidationDetails

Details about missing configuration for a node.
#missing_node_input ⇒ Types::MissingNodeInputFlowValidationDetails

Details about a missing required input in a node.
#missing_node_output ⇒ Types::MissingNodeOutputFlowValidationDetails

Details about a missing required output in a node.
#missing_starting_nodes ⇒ Types::MissingStartingNodesFlowValidationDetails

Details about missing starting nodes in the flow.
#multiple_loop_controller_nodes ⇒ Types::MultipleLoopControllerNodesFlowValidationDetails

Details about a flow that contains multiple ‘LoopController` nodes in a DoWhile loop.
#multiple_loop_input_nodes ⇒ Types::MultipleLoopInputNodesFlowValidationDetails

Details about a flow that contains multiple ‘LoopInput` nodes in a DoWhile loop.
#multiple_node_input_connections ⇒ Types::MultipleNodeInputConnectionsFlowValidationDetails

Details about multiple connections to a single node input.
#output ⇒ Types::OutputFlowNodeConfiguration

Contains configurations for an output flow node in your flow.
#payload ⇒ String

The JSON or YAML-formatted payload defining the OpenAPI schema for the action group.
#prompt ⇒ Types::PromptFlowNodeConfiguration

Contains configurations for a prompt node in your flow.
#resource ⇒ Types::PromptFlowNodeResourceConfiguration

Contains configurations for a prompt from Prompt management.
#retrieval ⇒ Types::RetrievalFlowNodeConfiguration

Contains configurations for a retrieval node in your flow.
#s3 ⇒ Types::StorageFlowNodeS3Configuration

Contains configurations for the Amazon S3 location in which to store the input into the node.
#storage ⇒ Types::StorageFlowNodeConfiguration

Contains configurations for a storage node in your flow.
#text ⇒ String

The text in the system prompt.
#tool ⇒ Types::SpecificToolChoice

Defines a specific tool that the model must request.
#tool_spec ⇒ Types::ToolSpecification

The specification for the tool.
#unfulfilled_node_input ⇒ Types::UnfulfilledNodeInputFlowValidationDetails

Details about an unfulfilled node input with no valid connections.
#unknown_connection_condition ⇒ Types::UnknownConnectionConditionFlowValidationDetails

Details about an unknown condition for a connection.
#unknown_connection_source ⇒ Types::UnknownConnectionSourceFlowValidationDetails

Details about an unknown source node for a connection.
#unknown_connection_source_output ⇒ Types::UnknownConnectionSourceOutputFlowValidationDetails

Details about an unknown source output for a connection.
#unknown_connection_target ⇒ Types::UnknownConnectionTargetFlowValidationDetails

Details about an unknown target node for a connection.
#unknown_connection_target_input ⇒ Types::UnknownConnectionTargetInputFlowValidationDetails

Details about an unknown target input for a connection.
#unknown_node_input ⇒ Types::UnknownNodeInputFlowValidationDetails

Details about an unknown input for a node.
#unknown_node_output ⇒ Types::UnknownNodeOutputFlowValidationDetails

Details about an unknown output for a node.
#unreachable_node ⇒ Types::UnreachableNodeFlowValidationDetails

Details about an unreachable node in the flow.
#unsatisfied_connection_conditions ⇒ Types::UnsatisfiedConnectionConditionsFlowValidationDetails

Details about unsatisfied conditions for a connection.
#unspecified ⇒ Types::UnspecifiedFlowValidationDetails

Details about an unspecified validation.

Instance Attribute Details

#agent ⇒ `Types::PromptAgentResource`

Specifies an Amazon Bedrock agent with which to use the prompt.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#any ⇒ `Types::AnyToolChoice`

Defines tools, at least one of which must be requested by the model. No text is generated but the results of tool use are sent back to the model to help generate a response.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 10233

class ToolChoice < Struct.new(
  :auto,
  :any,
  :tool,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Auto < ToolChoice; end
  class Any < ToolChoice; end
  class Tool < ToolChoice; end
  class Unknown < ToolChoice; end
end

#auto ⇒ `Types::AutoToolChoice`

Defines tools. The model automatically decides whether to call a tool or to generate text instead.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 10233

class ToolChoice < Struct.new(
  :auto,
  :any,
  :tool,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Auto < ToolChoice; end
  class Any < ToolChoice; end
  class Tool < ToolChoice; end
  class Unknown < ToolChoice; end
end

#cache_point ⇒ `Types::CachePointBlock`

Creates a cache checkpoint within a tool designation

# File 'lib/aws-sdk-bedrockagent/types.rb', line 1678

class ContentBlock < Struct.new(
  :text,
  :cache_point,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Text < ContentBlock; end
  class CachePoint < ContentBlock; end
  class Unknown < ContentBlock; end
end

#chat ⇒ `Types::ChatPromptTemplateConfiguration`

Contains configurations to use the prompt in a conversational format.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 8730

class PromptTemplateConfiguration < Struct.new(
  :text,
  :chat,
  :unknown)
  SENSITIVE = [:text, :chat]
  include Aws::Structure
  include Aws::Structure::Union

  class Text < PromptTemplateConfiguration; end
  class Chat < PromptTemplateConfiguration; end
  class Unknown < PromptTemplateConfiguration; end
end

#collector ⇒ `Types::CollectorFlowNodeConfiguration`

Contains configurations for a collector node in your flow. Collects an iteration of inputs and consolidates them into an array of outputs.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#condition ⇒ `Types::ConditionFlowNodeConfiguration`

Contains configurations for a condition node in your flow. Defines conditions that lead to different branches of the flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#conditional ⇒ `Types::FlowConditionalConnectionConfiguration`

The configuration of a connection originating from a Condition node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4025

class FlowConnectionConfiguration < Struct.new(
  :data,
  :conditional,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Data < FlowConnectionConfiguration; end
  class Conditional < FlowConnectionConfiguration; end
  class Unknown < FlowConnectionConfiguration; end
end

#custom_control ⇒ `String`

To return the action group invocation results directly in the ‘InvokeAgent` response, specify `RETURN_CONTROL`.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 95

class ActionGroupExecutor < Struct.new(
  :lambda,
  :custom_control,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Lambda < ActionGroupExecutor; end
  class CustomControl < ActionGroupExecutor; end
  class Unknown < ActionGroupExecutor; end
end

#cyclic_connection ⇒ `Types::CyclicConnectionFlowValidationDetails`

Details about a cyclic connection in the flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#data ⇒ `Types::FlowDataConnectionConfiguration`

The configuration of a connection originating from a node that isn’t a Condition node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4025

class FlowConnectionConfiguration < Struct.new(
  :data,
  :conditional,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Data < FlowConnectionConfiguration; end
  class Conditional < FlowConnectionConfiguration; end
  class Unknown < FlowConnectionConfiguration; end
end

#duplicate_condition_expression ⇒ `Types::DuplicateConditionExpressionFlowValidationDetails`

Details about duplicate condition expressions in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#duplicate_connections ⇒ `Types::DuplicateConnectionsFlowValidationDetails`

Details about duplicate connections between nodes.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#fields_to_exclude ⇒ `Array<Types::FieldForReranking>`

Specifies the metadata fields to exclude from the reranking process.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 9297

class RerankingMetadataSelectiveModeConfiguration < Struct.new(
  :fields_to_include,
  :fields_to_exclude,
  :unknown)
  SENSITIVE = [:fields_to_include, :fields_to_exclude]
  include Aws::Structure
  include Aws::Structure::Union

  class FieldsToInclude < RerankingMetadataSelectiveModeConfiguration; end
  class FieldsToExclude < RerankingMetadataSelectiveModeConfiguration; end
  class Unknown < RerankingMetadataSelectiveModeConfiguration; end
end

#fields_to_include ⇒ `Array<Types::FieldForReranking>`

Specifies the metadata fields to include in the reranking process.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 9297

class RerankingMetadataSelectiveModeConfiguration < Struct.new(
  :fields_to_include,
  :fields_to_exclude,
  :unknown)
  SENSITIVE = [:fields_to_include, :fields_to_exclude]
  include Aws::Structure
  include Aws::Structure::Union

  class FieldsToInclude < RerankingMetadataSelectiveModeConfiguration; end
  class FieldsToExclude < RerankingMetadataSelectiveModeConfiguration; end
  class Unknown < RerankingMetadataSelectiveModeConfiguration; end
end

#functions ⇒ `Array<Types::Function>`

A list of functions that each define an action in the action group.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4791

class FunctionSchema < Struct.new(
  :functions,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Functions < FunctionSchema; end
  class Unknown < FunctionSchema; end
end

#incompatible_connection_data_type ⇒ `Types::IncompatibleConnectionDataTypeFlowValidationDetails`

Details about incompatible data types in a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#inline ⇒ `Types::PromptFlowNodeInlineConfiguration`

Contains configurations for a prompt that is defined inline

# File 'lib/aws-sdk-bedrockagent/types.rb', line 8472

class PromptFlowNodeSourceConfiguration < Struct.new(
  :resource,
  :inline,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Resource < PromptFlowNodeSourceConfiguration; end
  class Inline < PromptFlowNodeSourceConfiguration; end
  class Unknown < PromptFlowNodeSourceConfiguration; end
end

#inline_code ⇒ `Types::InlineCodeFlowNodeConfiguration`

Contains configurations for an inline code node in your flow. Inline code nodes let you write and execute code directly within your flow, enabling data transformations, custom logic, and integrations without needing an external Lambda function.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#input ⇒ `Types::InputFlowNodeConfiguration`

Contains configurations for an input flow node in your flow. The first node in the flow. ‘inputs` can’t be specified for this node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#invalid_loop_boundary ⇒ `Types::InvalidLoopBoundaryFlowValidationDetails`

Details about a flow that includes connections that violate loop boundary rules.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#iterator ⇒ `Types::IteratorFlowNodeConfiguration`

Contains configurations for an iterator node in your flow. Takes an input that is an array and iteratively sends each item of the array as an output to the following node. The size of the array is also returned in the output.

The output flow node at the end of the flow iteration will return a response for each member of the array. To return only one response, you can include a collector node downstream from the iterator node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#json ⇒ `Hash`, ...

A JSON object defining the input schema for the tool.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 10290

class ToolInputSchema < Struct.new(
  :json,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Json < ToolInputSchema; end
  class Unknown < ToolInputSchema; end
end

#knowledge_base ⇒ `Types::KnowledgeBaseFlowNodeConfiguration`

Contains configurations for a knowledge base node in your flow. Queries a knowledge base and returns the retrieved results or generated response.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#lambda ⇒ `String`

The Amazon Resource Name (ARN) of the Lambda function containing the business logic that is carried out upon invoking the action.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 95

class ActionGroupExecutor < Struct.new(
  :lambda,
  :custom_control,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Lambda < ActionGroupExecutor; end
  class CustomControl < ActionGroupExecutor; end
  class Unknown < ActionGroupExecutor; end
end

#lambda_function ⇒ `Types::LambdaFunctionFlowNodeConfiguration`

Contains configurations for a Lambda function node in your flow. Invokes an Lambda function.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#lex ⇒ `Types::LexFlowNodeConfiguration`

Contains configurations for a Lex node in your flow. Invokes an Amazon Lex bot to identify the intent of the input and return the intent as the output.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#loop ⇒ `Types::LoopFlowNodeConfiguration`

Contains configurations for a DoWhile loop in your flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#loop_controller ⇒ `Types::LoopControllerFlowNodeConfiguration`

Contains controller node configurations for a DoWhile loop in your flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#loop_incompatible_node_type ⇒ `Types::LoopIncompatibleNodeTypeFlowValidationDetails`

Details about a flow that includes incompatible node types in a DoWhile loop.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#loop_input ⇒ `Types::LoopInputFlowNodeConfiguration`

Contains input node configurations for a DoWhile loop in your flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#malformed_condition_expression ⇒ `Types::MalformedConditionExpressionFlowValidationDetails`

Details about a malformed condition expression in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#malformed_node_input_expression ⇒ `Types::MalformedNodeInputExpressionFlowValidationDetails`

Details about a malformed input expression in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#mismatched_node_input_type ⇒ `Types::MismatchedNodeInputTypeFlowValidationDetails`

Details about mismatched input data types in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#mismatched_node_output_type ⇒ `Types::MismatchedNodeOutputTypeFlowValidationDetails`

Details about mismatched output data types in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_connection_configuration ⇒ `Types::MissingConnectionConfigurationFlowValidationDetails`

Details about missing configuration for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_default_condition ⇒ `Types::MissingDefaultConditionFlowValidationDetails`

Details about a missing default condition in a conditional node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_ending_nodes ⇒ `Types::MissingEndingNodesFlowValidationDetails`

Details about missing ending nodes in the flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_loop_controller_node ⇒ `Types::MissingLoopControllerNodeFlowValidationDetails`

Details about a flow that’s missing a required ‘LoopController` node in a DoWhile loop.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_loop_input_node ⇒ `Types::MissingLoopInputNodeFlowValidationDetails`

Details about a flow that’s missing a required ‘LoopInput` node in a DoWhile loop.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_node_configuration ⇒ `Types::MissingNodeConfigurationFlowValidationDetails`

Details about missing configuration for a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_node_input ⇒ `Types::MissingNodeInputFlowValidationDetails`

Details about a missing required input in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_node_output ⇒ `Types::MissingNodeOutputFlowValidationDetails`

Details about a missing required output in a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#missing_starting_nodes ⇒ `Types::MissingStartingNodesFlowValidationDetails`

Details about missing starting nodes in the flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#multiple_loop_controller_nodes ⇒ `Types::MultipleLoopControllerNodesFlowValidationDetails`

Details about a flow that contains multiple ‘LoopController` nodes in a DoWhile loop.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#multiple_loop_input_nodes ⇒ `Types::MultipleLoopInputNodesFlowValidationDetails`

Details about a flow that contains multiple ‘LoopInput` nodes in a DoWhile loop.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#multiple_node_input_connections ⇒ `Types::MultipleNodeInputConnectionsFlowValidationDetails`

Details about multiple connections to a single node input.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#output ⇒ `Types::OutputFlowNodeConfiguration`

Contains configurations for an output flow node in your flow. The last node in the flow. ‘outputs` can’t be specified for this node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#payload ⇒ `String`

The JSON or YAML-formatted payload defining the OpenAPI schema for the action group. For more information, see [Action group OpenAPI schemas].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/agents-api-schema.html

# File 'lib/aws-sdk-bedrockagent/types.rb', line 49

class APISchema < Struct.new(
  :s3,
  :payload,
  :unknown)
  SENSITIVE = [:payload]
  include Aws::Structure
  include Aws::Structure::Union

  class S3 < APISchema; end
  class Payload < APISchema; end
  class Unknown < APISchema; end
end

#prompt ⇒ `Types::PromptFlowNodeConfiguration`

Contains configurations for a prompt node in your flow. Runs a prompt and generates the model response as the output. You can use a prompt from Prompt management or you can configure one in this node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#resource ⇒ `Types::PromptFlowNodeResourceConfiguration`

Contains configurations for a prompt from Prompt management.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 8472

class PromptFlowNodeSourceConfiguration < Struct.new(
  :resource,
  :inline,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Resource < PromptFlowNodeSourceConfiguration; end
  class Inline < PromptFlowNodeSourceConfiguration; end
  class Unknown < PromptFlowNodeSourceConfiguration; end
end

#retrieval ⇒ `Types::RetrievalFlowNodeConfiguration`

Contains configurations for a retrieval node in your flow. Retrieves data from an Amazon S3 location and returns it as the output.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#s3 ⇒ `Types::StorageFlowNodeS3Configuration`

Contains configurations for the Amazon S3 location in which to store the input into the node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 49

class APISchema < Struct.new(
  :s3,
  :payload,
  :unknown)
  SENSITIVE = [:payload]
  include Aws::Structure
  include Aws::Structure::Union

  class S3 < APISchema; end
  class Payload < APISchema; end
  class Unknown < APISchema; end
end

#storage ⇒ `Types::StorageFlowNodeConfiguration`

Contains configurations for a storage node in your flow. Stores an input in an Amazon S3 location.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4220

class FlowNodeConfiguration < Struct.new(
  :input,
  :output,
  :knowledge_base,
  :condition,
  :lex,
  :prompt,
  :lambda_function,
  :storage,
  :agent,
  :retrieval,
  :iterator,
  :collector,
  :inline_code,
  :loop,
  :loop_input,
  :loop_controller,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Input < FlowNodeConfiguration; end
  class Output < FlowNodeConfiguration; end
  class KnowledgeBase < FlowNodeConfiguration; end
  class Condition < FlowNodeConfiguration; end
  class Lex < FlowNodeConfiguration; end
  class Prompt < FlowNodeConfiguration; end
  class LambdaFunction < FlowNodeConfiguration; end
  class Storage < FlowNodeConfiguration; end
  class Agent < FlowNodeConfiguration; end
  class Retrieval < FlowNodeConfiguration; end
  class Iterator < FlowNodeConfiguration; end
  class Collector < FlowNodeConfiguration; end
  class InlineCode < FlowNodeConfiguration; end
  class Loop < FlowNodeConfiguration; end
  class LoopInput < FlowNodeConfiguration; end
  class LoopController < FlowNodeConfiguration; end
  class Unknown < FlowNodeConfiguration; end
end

#text ⇒ `String`

The text in the system prompt.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 1678

class ContentBlock < Struct.new(
  :text,
  :cache_point,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Text < ContentBlock; end
  class CachePoint < ContentBlock; end
  class Unknown < ContentBlock; end
end

#tool ⇒ `Types::SpecificToolChoice`

Defines a specific tool that the model must request. No text is generated but the results of tool use are sent back to the model to help generate a response.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 10233

class ToolChoice < Struct.new(
  :auto,
  :any,
  :tool,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class Auto < ToolChoice; end
  class Any < ToolChoice; end
  class Tool < ToolChoice; end
  class Unknown < ToolChoice; end
end

#tool_spec ⇒ `Types::ToolSpecification`

The specification for the tool.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 10189

class Tool < Struct.new(
  :tool_spec,
  :cache_point,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class ToolSpec < Tool; end
  class CachePoint < Tool; end
  class Unknown < Tool; end
end

#unfulfilled_node_input ⇒ `Types::UnfulfilledNodeInputFlowValidationDetails`

Details about an unfulfilled node input with no valid connections.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_connection_condition ⇒ `Types::UnknownConnectionConditionFlowValidationDetails`

Details about an unknown condition for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_connection_source ⇒ `Types::UnknownConnectionSourceFlowValidationDetails`

Details about an unknown source node for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_connection_source_output ⇒ `Types::UnknownConnectionSourceOutputFlowValidationDetails`

Details about an unknown source output for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_connection_target ⇒ `Types::UnknownConnectionTargetFlowValidationDetails`

Details about an unknown target node for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_connection_target_input ⇒ `Types::UnknownConnectionTargetInputFlowValidationDetails`

Details about an unknown target input for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_node_input ⇒ `Types::UnknownNodeInputFlowValidationDetails`

Details about an unknown input for a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unknown_node_output ⇒ `Types::UnknownNodeOutputFlowValidationDetails`

Details about an unknown output for a node.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unreachable_node ⇒ `Types::UnreachableNodeFlowValidationDetails`

Details about an unreachable node in the flow.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unsatisfied_connection_conditions ⇒ `Types::UnsatisfiedConnectionConditionsFlowValidationDetails`

Details about unsatisfied conditions for a connection.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

#unspecified ⇒ `Types::UnspecifiedFlowValidationDetails`

Details about an unspecified validation.

# File 'lib/aws-sdk-bedrockagent/types.rb', line 4585

class FlowValidationDetails < Struct.new(
  :cyclic_connection,
  :duplicate_connections,
  :duplicate_condition_expression,
  :unreachable_node,
  :unknown_connection_source,
  :unknown_connection_source_output,
  :unknown_connection_target,
  :unknown_connection_target_input,
  :unknown_connection_condition,
  :malformed_condition_expression,
  :malformed_node_input_expression,
  :mismatched_node_input_type,
  :mismatched_node_output_type,
  :incompatible_connection_data_type,
  :missing_connection_configuration,
  :missing_default_condition,
  :missing_ending_nodes,
  :missing_node_configuration,
  :missing_node_input,
  :missing_node_output,
  :missing_starting_nodes,
  :multiple_node_input_connections,
  :unfulfilled_node_input,
  :unsatisfied_connection_conditions,
  :unspecified,
  :unknown_node_input,
  :unknown_node_output,
  :missing_loop_input_node,
  :missing_loop_controller_node,
  :multiple_loop_input_nodes,
  :multiple_loop_controller_nodes,
  :loop_incompatible_node_type,
  :invalid_loop_boundary,
  :unknown)
  SENSITIVE = []
  include Aws::Structure
  include Aws::Structure::Union

  class CyclicConnection < FlowValidationDetails; end
  class DuplicateConnections < FlowValidationDetails; end
  class DuplicateConditionExpression < FlowValidationDetails; end
  class UnreachableNode < FlowValidationDetails; end
  class UnknownConnectionSource < FlowValidationDetails; end
  class UnknownConnectionSourceOutput < FlowValidationDetails; end
  class UnknownConnectionTarget < FlowValidationDetails; end
  class UnknownConnectionTargetInput < FlowValidationDetails; end
  class UnknownConnectionCondition < FlowValidationDetails; end
  class MalformedConditionExpression < FlowValidationDetails; end
  class MalformedNodeInputExpression < FlowValidationDetails; end
  class MismatchedNodeInputType < FlowValidationDetails; end
  class MismatchedNodeOutputType < FlowValidationDetails; end
  class IncompatibleConnectionDataType < FlowValidationDetails; end
  class MissingConnectionConfiguration < FlowValidationDetails; end
  class MissingDefaultCondition < FlowValidationDetails; end
  class MissingEndingNodes < FlowValidationDetails; end
  class MissingNodeConfiguration < FlowValidationDetails; end
  class MissingNodeInput < FlowValidationDetails; end
  class MissingNodeOutput < FlowValidationDetails; end
  class MissingStartingNodes < FlowValidationDetails; end
  class MultipleNodeInputConnections < FlowValidationDetails; end
  class UnfulfilledNodeInput < FlowValidationDetails; end
  class UnsatisfiedConnectionConditions < FlowValidationDetails; end
  class Unspecified < FlowValidationDetails; end
  class UnknownNodeInput < FlowValidationDetails; end
  class UnknownNodeOutput < FlowValidationDetails; end
  class MissingLoopInputNode < FlowValidationDetails; end
  class MissingLoopControllerNode < FlowValidationDetails; end
  class MultipleLoopInputNodes < FlowValidationDetails; end
  class MultipleLoopControllerNodes < FlowValidationDetails; end
  class LoopIncompatibleNodeType < FlowValidationDetails; end
  class InvalidLoopBoundary < FlowValidationDetails; end
  class Unknown < FlowValidationDetails; end
end

Module: Aws::BedrockAgent::Types

Defined Under Namespace

Instance Attribute Summary collapse

Instance Attribute Details

#agent ⇒ Types::PromptAgentResource

#any ⇒ Types::AnyToolChoice

#auto ⇒ Types::AutoToolChoice

#cache_point ⇒ Types::CachePointBlock

#chat ⇒ Types::ChatPromptTemplateConfiguration

#collector ⇒ Types::CollectorFlowNodeConfiguration

#condition ⇒ Types::ConditionFlowNodeConfiguration

#conditional ⇒ Types::FlowConditionalConnectionConfiguration

#custom_control ⇒ String

#cyclic_connection ⇒ Types::CyclicConnectionFlowValidationDetails

#data ⇒ Types::FlowDataConnectionConfiguration

#duplicate_condition_expression ⇒ Types::DuplicateConditionExpressionFlowValidationDetails

#duplicate_connections ⇒ Types::DuplicateConnectionsFlowValidationDetails

#fields_to_exclude ⇒ Array<Types::FieldForReranking>

#fields_to_include ⇒ Array<Types::FieldForReranking>

#functions ⇒ Array<Types::Function>

#incompatible_connection_data_type ⇒ Types::IncompatibleConnectionDataTypeFlowValidationDetails

#inline ⇒ Types::PromptFlowNodeInlineConfiguration

#inline_code ⇒ Types::InlineCodeFlowNodeConfiguration

#input ⇒ Types::InputFlowNodeConfiguration

#invalid_loop_boundary ⇒ Types::InvalidLoopBoundaryFlowValidationDetails

#iterator ⇒ Types::IteratorFlowNodeConfiguration

#json ⇒ Hash, ...

#knowledge_base ⇒ Types::KnowledgeBaseFlowNodeConfiguration

#lambda ⇒ String

#lambda_function ⇒ Types::LambdaFunctionFlowNodeConfiguration

#lex ⇒ Types::LexFlowNodeConfiguration

#loop ⇒ Types::LoopFlowNodeConfiguration

#loop_controller ⇒ Types::LoopControllerFlowNodeConfiguration

#loop_incompatible_node_type ⇒ Types::LoopIncompatibleNodeTypeFlowValidationDetails

#loop_input ⇒ Types::LoopInputFlowNodeConfiguration

#malformed_condition_expression ⇒ Types::MalformedConditionExpressionFlowValidationDetails

#malformed_node_input_expression ⇒ Types::MalformedNodeInputExpressionFlowValidationDetails

#mismatched_node_input_type ⇒ Types::MismatchedNodeInputTypeFlowValidationDetails

#mismatched_node_output_type ⇒ Types::MismatchedNodeOutputTypeFlowValidationDetails

#missing_connection_configuration ⇒ Types::MissingConnectionConfigurationFlowValidationDetails

#missing_default_condition ⇒ Types::MissingDefaultConditionFlowValidationDetails

#missing_ending_nodes ⇒ Types::MissingEndingNodesFlowValidationDetails

#missing_loop_controller_node ⇒ Types::MissingLoopControllerNodeFlowValidationDetails

#missing_loop_input_node ⇒ Types::MissingLoopInputNodeFlowValidationDetails

#missing_node_configuration ⇒ Types::MissingNodeConfigurationFlowValidationDetails

#missing_node_input ⇒ Types::MissingNodeInputFlowValidationDetails

#missing_node_output ⇒ Types::MissingNodeOutputFlowValidationDetails

#missing_starting_nodes ⇒ Types::MissingStartingNodesFlowValidationDetails

#multiple_loop_controller_nodes ⇒ Types::MultipleLoopControllerNodesFlowValidationDetails

#multiple_loop_input_nodes ⇒ Types::MultipleLoopInputNodesFlowValidationDetails

#multiple_node_input_connections ⇒ Types::MultipleNodeInputConnectionsFlowValidationDetails

#output ⇒ Types::OutputFlowNodeConfiguration

#payload ⇒ String

#prompt ⇒ Types::PromptFlowNodeConfiguration

#resource ⇒ Types::PromptFlowNodeResourceConfiguration

#retrieval ⇒ Types::RetrievalFlowNodeConfiguration

#s3 ⇒ Types::StorageFlowNodeS3Configuration

#storage ⇒ Types::StorageFlowNodeConfiguration

#text ⇒ String

#tool ⇒ Types::SpecificToolChoice

#tool_spec ⇒ Types::ToolSpecification

#unfulfilled_node_input ⇒ Types::UnfulfilledNodeInputFlowValidationDetails

#unknown_connection_condition ⇒ Types::UnknownConnectionConditionFlowValidationDetails

#unknown_connection_source ⇒ Types::UnknownConnectionSourceFlowValidationDetails

#unknown_connection_source_output ⇒ Types::UnknownConnectionSourceOutputFlowValidationDetails

#unknown_connection_target ⇒ Types::UnknownConnectionTargetFlowValidationDetails

#unknown_connection_target_input ⇒ Types::UnknownConnectionTargetInputFlowValidationDetails

#unknown_node_input ⇒ Types::UnknownNodeInputFlowValidationDetails

#unknown_node_output ⇒ Types::UnknownNodeOutputFlowValidationDetails

#unreachable_node ⇒ Types::UnreachableNodeFlowValidationDetails

#unsatisfied_connection_conditions ⇒ Types::UnsatisfiedConnectionConditionsFlowValidationDetails

#unspecified ⇒ Types::UnspecifiedFlowValidationDetails