@aws-sdk/client-bedrock-agent 3.685.0 → 3.687.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -903,6 +903,7 @@ export interface IteratorFlowNodeConfiguration {}
 export interface KnowledgeBaseFlowNodeConfiguration {
   knowledgeBaseId: string | undefined;
   modelId?: string;
+  guardrailConfiguration?: GuardrailConfiguration;
 }
 export interface LambdaFunctionFlowNodeConfiguration {
   lambdaArn: string | undefined;
@@ -942,24 +943,171 @@ export declare namespace PromptInferenceConfiguration {
 export interface PromptInputVariable {
   name?: string;
 }
+export type ContentBlock =
+  | ContentBlock.TextMember
+  | ContentBlock.$UnknownMember;
+export declare namespace ContentBlock {
+  interface TextMember {
+    text: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ContentBlock, visitor: Visitor<T>) => T;
+}
+export declare const ConversationRole: {
+  readonly ASSISTANT: "assistant";
+  readonly USER: "user";
+};
+export type ConversationRole =
+  (typeof ConversationRole)[keyof typeof ConversationRole];
+export interface Message {
+  role: ConversationRole | undefined;
+  content: ContentBlock[] | undefined;
+}
+export type SystemContentBlock =
+  | SystemContentBlock.TextMember
+  | SystemContentBlock.$UnknownMember;
+export declare namespace SystemContentBlock {
+  interface TextMember {
+    text: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: SystemContentBlock, visitor: Visitor<T>) => T;
+}
+export interface AnyToolChoice {}
+export interface AutoToolChoice {}
+export interface SpecificToolChoice {
+  name: string | undefined;
+}
+export type ToolChoice =
+  | ToolChoice.AnyMember
+  | ToolChoice.AutoMember
+  | ToolChoice.ToolMember
+  | ToolChoice.$UnknownMember;
+export declare namespace ToolChoice {
+  interface AutoMember {
+    auto: AutoToolChoice;
+    any?: never;
+    tool?: never;
+    $unknown?: never;
+  }
+  interface AnyMember {
+    auto?: never;
+    any: AnyToolChoice;
+    tool?: never;
+    $unknown?: never;
+  }
+  interface ToolMember {
+    auto?: never;
+    any?: never;
+    tool: SpecificToolChoice;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    auto?: never;
+    any?: never;
+    tool?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    auto: (value: AutoToolChoice) => T;
+    any: (value: AnyToolChoice) => T;
+    tool: (value: SpecificToolChoice) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ToolChoice, visitor: Visitor<T>) => T;
+}
+export type ToolInputSchema =
+  | ToolInputSchema.JsonMember
+  | ToolInputSchema.$UnknownMember;
+export declare namespace ToolInputSchema {
+  interface JsonMember {
+    json: __DocumentType;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    json?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    json: (value: __DocumentType) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ToolInputSchema, visitor: Visitor<T>) => T;
+}
+export interface ToolSpecification {
+  name: string | undefined;
+  description?: string;
+  inputSchema: ToolInputSchema | undefined;
+}
+export type Tool = Tool.ToolSpecMember | Tool.$UnknownMember;
+export declare namespace Tool {
+  interface ToolSpecMember {
+    toolSpec: ToolSpecification;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    toolSpec?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    toolSpec: (value: ToolSpecification) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: Tool, visitor: Visitor<T>) => T;
+}
+export interface ToolConfiguration {
+  tools: Tool[] | undefined;
+  toolChoice?: ToolChoice;
+}
+export interface ChatPromptTemplateConfiguration {
+  messages: Message[] | undefined;
+  system?: SystemContentBlock[];
+  inputVariables?: PromptInputVariable[];
+  toolConfiguration?: ToolConfiguration;
+}
 export interface TextPromptTemplateConfiguration {
   text: string | undefined;
   inputVariables?: PromptInputVariable[];
 }
 export type PromptTemplateConfiguration =
+  | PromptTemplateConfiguration.ChatMember
   | PromptTemplateConfiguration.TextMember
   | PromptTemplateConfiguration.$UnknownMember;
 export declare namespace PromptTemplateConfiguration {
   interface TextMember {
     text: TextPromptTemplateConfiguration;
+    chat?: never;
+    $unknown?: never;
+  }
+  interface ChatMember {
+    text?: never;
+    chat: ChatPromptTemplateConfiguration;
     $unknown?: never;
   }
   interface $UnknownMember {
     text?: never;
+    chat?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     text: (value: TextPromptTemplateConfiguration) => T;
+    chat: (value: ChatPromptTemplateConfiguration) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(
@@ -968,6 +1116,7 @@ export declare namespace PromptTemplateConfiguration {
   ) => T;
 }
 export declare const PromptTemplateType: {
+  readonly CHAT: "CHAT";
   readonly TEXT: "TEXT";
 };
 export type PromptTemplateType =
@@ -1014,6 +1163,7 @@ export declare namespace PromptFlowNodeSourceConfiguration {
 }
 export interface PromptFlowNodeConfiguration {
   sourceConfiguration: PromptFlowNodeSourceConfiguration | undefined;
+  guardrailConfiguration?: GuardrailConfiguration;
 }
 export interface RetrievalFlowNodeS3Configuration {
   bucketName: string | undefined;
@@ -1516,15 +1666,953 @@ export interface ListFlowVersionsResponse {
 export interface GetFlowRequest {
   flowIdentifier: string | undefined;
 }
+export interface CyclicConnectionFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface DuplicateConditionExpressionFlowValidationDetails {
+  node: string | undefined;
+  expression: string | undefined;
+}
+export interface DuplicateConnectionsFlowValidationDetails {
+  source: string | undefined;
+  target: string | undefined;
+}
+export interface IncompatibleConnectionDataTypeFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface MalformedConditionExpressionFlowValidationDetails {
+  node: string | undefined;
+  condition: string | undefined;
+  cause: string | undefined;
+}
+export interface MalformedNodeInputExpressionFlowValidationDetails {
+  node: string | undefined;
+  input: string | undefined;
+  cause: string | undefined;
+}
+export interface MismatchedNodeInputTypeFlowValidationDetails {
+  node: string | undefined;
+  input: string | undefined;
+  expectedType: FlowNodeIODataType | undefined;
+}
+export interface MismatchedNodeOutputTypeFlowValidationDetails {
+  node: string | undefined;
+  output: string | undefined;
+  expectedType: FlowNodeIODataType | undefined;
+}
+export interface MissingConnectionConfigurationFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface MissingDefaultConditionFlowValidationDetails {
+  node: string | undefined;
+}
+export interface MissingEndingNodesFlowValidationDetails {}
+export interface MissingNodeConfigurationFlowValidationDetails {
+  node: string | undefined;
+}
+export interface MissingNodeInputFlowValidationDetails {
+  node: string | undefined;
+  input: string | undefined;
+}
+export interface MissingNodeOutputFlowValidationDetails {
+  node: string | undefined;
+  output: string | undefined;
+}
+export interface MissingStartingNodesFlowValidationDetails {}
+export interface MultipleNodeInputConnectionsFlowValidationDetails {
+  node: string | undefined;
+  input: string | undefined;
+}
+export interface UnfulfilledNodeInputFlowValidationDetails {
+  node: string | undefined;
+  input: string | undefined;
+}
+export interface UnknownConnectionConditionFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface UnknownConnectionSourceFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface UnknownConnectionSourceOutputFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface UnknownConnectionTargetFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface UnknownConnectionTargetInputFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface UnreachableNodeFlowValidationDetails {
+  node: string | undefined;
+}
+export interface UnsatisfiedConnectionConditionsFlowValidationDetails {
+  connection: string | undefined;
+}
+export interface UnspecifiedFlowValidationDetails {}
+export type FlowValidationDetails =
+  | FlowValidationDetails.CyclicConnectionMember
+  | FlowValidationDetails.DuplicateConditionExpressionMember
+  | FlowValidationDetails.DuplicateConnectionsMember
+  | FlowValidationDetails.IncompatibleConnectionDataTypeMember
+  | FlowValidationDetails.MalformedConditionExpressionMember
+  | FlowValidationDetails.MalformedNodeInputExpressionMember
+  | FlowValidationDetails.MismatchedNodeInputTypeMember
+  | FlowValidationDetails.MismatchedNodeOutputTypeMember
+  | FlowValidationDetails.MissingConnectionConfigurationMember
+  | FlowValidationDetails.MissingDefaultConditionMember
+  | FlowValidationDetails.MissingEndingNodesMember
+  | FlowValidationDetails.MissingNodeConfigurationMember
+  | FlowValidationDetails.MissingNodeInputMember
+  | FlowValidationDetails.MissingNodeOutputMember
+  | FlowValidationDetails.MissingStartingNodesMember
+  | FlowValidationDetails.MultipleNodeInputConnectionsMember
+  | FlowValidationDetails.UnfulfilledNodeInputMember
+  | FlowValidationDetails.UnknownConnectionConditionMember
+  | FlowValidationDetails.UnknownConnectionSourceMember
+  | FlowValidationDetails.UnknownConnectionSourceOutputMember
+  | FlowValidationDetails.UnknownConnectionTargetMember
+  | FlowValidationDetails.UnknownConnectionTargetInputMember
+  | FlowValidationDetails.UnreachableNodeMember
+  | FlowValidationDetails.UnsatisfiedConnectionConditionsMember
+  | FlowValidationDetails.UnspecifiedMember
+  | FlowValidationDetails.$UnknownMember;
+export declare namespace FlowValidationDetails {
+  interface CyclicConnectionMember {
+    cyclicConnection: CyclicConnectionFlowValidationDetails;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface DuplicateConnectionsMember {
+    cyclicConnection?: never;
+    duplicateConnections: DuplicateConnectionsFlowValidationDetails;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface DuplicateConditionExpressionMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression: DuplicateConditionExpressionFlowValidationDetails;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnreachableNodeMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode: UnreachableNodeFlowValidationDetails;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnknownConnectionSourceMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource: UnknownConnectionSourceFlowValidationDetails;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnknownConnectionSourceOutputMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput: UnknownConnectionSourceOutputFlowValidationDetails;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnknownConnectionTargetMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget: UnknownConnectionTargetFlowValidationDetails;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnknownConnectionTargetInputMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput: UnknownConnectionTargetInputFlowValidationDetails;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnknownConnectionConditionMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition: UnknownConnectionConditionFlowValidationDetails;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MalformedConditionExpressionMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression: MalformedConditionExpressionFlowValidationDetails;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MalformedNodeInputExpressionMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression: MalformedNodeInputExpressionFlowValidationDetails;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MismatchedNodeInputTypeMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType: MismatchedNodeInputTypeFlowValidationDetails;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MismatchedNodeOutputTypeMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType: MismatchedNodeOutputTypeFlowValidationDetails;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface IncompatibleConnectionDataTypeMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType: IncompatibleConnectionDataTypeFlowValidationDetails;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingConnectionConfigurationMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration: MissingConnectionConfigurationFlowValidationDetails;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingDefaultConditionMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition: MissingDefaultConditionFlowValidationDetails;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingEndingNodesMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes: MissingEndingNodesFlowValidationDetails;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingNodeConfigurationMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration: MissingNodeConfigurationFlowValidationDetails;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingNodeInputMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput: MissingNodeInputFlowValidationDetails;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingNodeOutputMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput: MissingNodeOutputFlowValidationDetails;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MissingStartingNodesMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes: MissingStartingNodesFlowValidationDetails;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface MultipleNodeInputConnectionsMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections: MultipleNodeInputConnectionsFlowValidationDetails;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnfulfilledNodeInputMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput: UnfulfilledNodeInputFlowValidationDetails;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnsatisfiedConnectionConditionsMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions: UnsatisfiedConnectionConditionsFlowValidationDetails;
+    unspecified?: never;
+    $unknown?: never;
+  }
+  interface UnspecifiedMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified: UnspecifiedFlowValidationDetails;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    cyclicConnection?: never;
+    duplicateConnections?: never;
+    duplicateConditionExpression?: never;
+    unreachableNode?: never;
+    unknownConnectionSource?: never;
+    unknownConnectionSourceOutput?: never;
+    unknownConnectionTarget?: never;
+    unknownConnectionTargetInput?: never;
+    unknownConnectionCondition?: never;
+    malformedConditionExpression?: never;
+    malformedNodeInputExpression?: never;
+    mismatchedNodeInputType?: never;
+    mismatchedNodeOutputType?: never;
+    incompatibleConnectionDataType?: never;
+    missingConnectionConfiguration?: never;
+    missingDefaultCondition?: never;
+    missingEndingNodes?: never;
+    missingNodeConfiguration?: never;
+    missingNodeInput?: never;
+    missingNodeOutput?: never;
+    missingStartingNodes?: never;
+    multipleNodeInputConnections?: never;
+    unfulfilledNodeInput?: never;
+    unsatisfiedConnectionConditions?: never;
+    unspecified?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    cyclicConnection: (value: CyclicConnectionFlowValidationDetails) => T;
+    duplicateConnections: (
+      value: DuplicateConnectionsFlowValidationDetails
+    ) => T;
+    duplicateConditionExpression: (
+      value: DuplicateConditionExpressionFlowValidationDetails
+    ) => T;
+    unreachableNode: (value: UnreachableNodeFlowValidationDetails) => T;
+    unknownConnectionSource: (
+      value: UnknownConnectionSourceFlowValidationDetails
+    ) => T;
+    unknownConnectionSourceOutput: (
+      value: UnknownConnectionSourceOutputFlowValidationDetails
+    ) => T;
+    unknownConnectionTarget: (
+      value: UnknownConnectionTargetFlowValidationDetails
+    ) => T;
+    unknownConnectionTargetInput: (
+      value: UnknownConnectionTargetInputFlowValidationDetails
+    ) => T;
+    unknownConnectionCondition: (
+      value: UnknownConnectionConditionFlowValidationDetails
+    ) => T;
+    malformedConditionExpression: (
+      value: MalformedConditionExpressionFlowValidationDetails
+    ) => T;
+    malformedNodeInputExpression: (
+      value: MalformedNodeInputExpressionFlowValidationDetails
+    ) => T;
+    mismatchedNodeInputType: (
+      value: MismatchedNodeInputTypeFlowValidationDetails
+    ) => T;
+    mismatchedNodeOutputType: (
+      value: MismatchedNodeOutputTypeFlowValidationDetails
+    ) => T;
+    incompatibleConnectionDataType: (
+      value: IncompatibleConnectionDataTypeFlowValidationDetails
+    ) => T;
+    missingConnectionConfiguration: (
+      value: MissingConnectionConfigurationFlowValidationDetails
+    ) => T;
+    missingDefaultCondition: (
+      value: MissingDefaultConditionFlowValidationDetails
+    ) => T;
+    missingEndingNodes: (value: MissingEndingNodesFlowValidationDetails) => T;
+    missingNodeConfiguration: (
+      value: MissingNodeConfigurationFlowValidationDetails
+    ) => T;
+    missingNodeInput: (value: MissingNodeInputFlowValidationDetails) => T;
+    missingNodeOutput: (value: MissingNodeOutputFlowValidationDetails) => T;
+    missingStartingNodes: (
+      value: MissingStartingNodesFlowValidationDetails
+    ) => T;
+    multipleNodeInputConnections: (
+      value: MultipleNodeInputConnectionsFlowValidationDetails
+    ) => T;
+    unfulfilledNodeInput: (
+      value: UnfulfilledNodeInputFlowValidationDetails
+    ) => T;
+    unsatisfiedConnectionConditions: (
+      value: UnsatisfiedConnectionConditionsFlowValidationDetails
+    ) => T;
+    unspecified: (value: UnspecifiedFlowValidationDetails) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: FlowValidationDetails, visitor: Visitor<T>) => T;
+}
 export declare const FlowValidationSeverity: {
   readonly ERROR: "Error";
   readonly WARNING: "Warning";
 };
 export type FlowValidationSeverity =
   (typeof FlowValidationSeverity)[keyof typeof FlowValidationSeverity];
+export declare const FlowValidationType: {
+  readonly CYCLIC_CONNECTION: "CyclicConnection";
+  readonly DUPLICATE_CONDITION_EXPRESSION: "DuplicateConditionExpression";
+  readonly DUPLICATE_CONNECTIONS: "DuplicateConnections";
+  readonly INCOMPATIBLE_CONNECTION_DATA_TYPE: "IncompatibleConnectionDataType";
+  readonly MALFORMED_CONDITION_EXPRESSION: "MalformedConditionExpression";
+  readonly MALFORMED_NODE_INPUT_EXPRESSION: "MalformedNodeInputExpression";
+  readonly MISMATCHED_NODE_INPUT_TYPE: "MismatchedNodeInputType";
+  readonly MISMATCHED_NODE_OUTPUT_TYPE: "MismatchedNodeOutputType";
+  readonly MISSING_CONNECTION_CONFIGURATION: "MissingConnectionConfiguration";
+  readonly MISSING_DEFAULT_CONDITION: "MissingDefaultCondition";
+  readonly MISSING_ENDING_NODES: "MissingEndingNodes";
+  readonly MISSING_NODE_CONFIGURATION: "MissingNodeConfiguration";
+  readonly MISSING_NODE_INPUT: "MissingNodeInput";
+  readonly MISSING_NODE_OUTPUT: "MissingNodeOutput";
+  readonly MISSING_STARTING_NODES: "MissingStartingNodes";
+  readonly MULTIPLE_NODE_INPUT_CONNECTIONS: "MultipleNodeInputConnections";
+  readonly UNFULFILLED_NODE_INPUT: "UnfulfilledNodeInput";
+  readonly UNKNOWN_CONNECTION_CONDITION: "UnknownConnectionCondition";
+  readonly UNKNOWN_CONNECTION_SOURCE: "UnknownConnectionSource";
+  readonly UNKNOWN_CONNECTION_SOURCE_OUTPUT: "UnknownConnectionSourceOutput";
+  readonly UNKNOWN_CONNECTION_TARGET: "UnknownConnectionTarget";
+  readonly UNKNOWN_CONNECTION_TARGET_INPUT: "UnknownConnectionTargetInput";
+  readonly UNREACHABLE_NODE: "UnreachableNode";
+  readonly UNSATISFIED_CONNECTION_CONDITIONS: "UnsatisfiedConnectionConditions";
+  readonly UNSPECIFIED: "Unspecified";
+};
+export type FlowValidationType =
+  (typeof FlowValidationType)[keyof typeof FlowValidationType];
 export interface FlowValidation {
   message: string | undefined;
   severity: FlowValidationSeverity | undefined;
+  details?: FlowValidationDetails;
+  type?: FlowValidationType;
 }
 export interface GetFlowResponse {
   name: string | undefined;
@@ -1859,208 +2947,6 @@ export interface GetKnowledgeBaseRequest {
 export interface GetKnowledgeBaseResponse {
   knowledgeBase: KnowledgeBase | undefined;
 }
-export interface ListAgentKnowledgeBasesRequest {
-  agentId: string | undefined;
-  agentVersion: string | undefined;
-  maxResults?: number;
-  nextToken?: string;
-}
-export interface ListAgentKnowledgeBasesResponse {
-  agentKnowledgeBaseSummaries: AgentKnowledgeBaseSummary[] | undefined;
-  nextToken?: string;
-}
-export interface ListKnowledgeBasesRequest {
-  maxResults?: number;
-  nextToken?: string;
-}
-export interface KnowledgeBaseSummary {
-  knowledgeBaseId: string | undefined;
-  name: string | undefined;
-  description?: string;
-  status: KnowledgeBaseStatus | undefined;
-  updatedAt: Date | undefined;
-}
-export interface ListKnowledgeBasesResponse {
-  knowledgeBaseSummaries: KnowledgeBaseSummary[] | undefined;
-  nextToken?: string;
-}
-export interface UpdateAgentKnowledgeBaseRequest {
-  agentId: string | undefined;
-  agentVersion: string | undefined;
-  knowledgeBaseId: string | undefined;
-  description?: string;
-  knowledgeBaseState?: KnowledgeBaseState;
-}
-export interface UpdateAgentKnowledgeBaseResponse {
-  agentKnowledgeBase: AgentKnowledgeBase | undefined;
-}
-export interface UpdateKnowledgeBaseRequest {
-  knowledgeBaseId: string | undefined;
-  name: string | undefined;
-  description?: string;
-  roleArn: string | undefined;
-  knowledgeBaseConfiguration: KnowledgeBaseConfiguration | undefined;
-  storageConfiguration: StorageConfiguration | undefined;
-}
-export interface UpdateKnowledgeBaseResponse {
-  knowledgeBase: KnowledgeBase | undefined;
-}
-export interface PromptMetadataEntry {
-  key: string | undefined;
-  value: string | undefined;
-}
-export interface PromptVariant {
-  name: string | undefined;
-  templateType: PromptTemplateType | undefined;
-  templateConfiguration: PromptTemplateConfiguration | undefined;
-  modelId?: string;
-  inferenceConfiguration?: PromptInferenceConfiguration;
-  metadata?: PromptMetadataEntry[];
-  additionalModelRequestFields?: __DocumentType;
-}
-export interface CreatePromptRequest {
-  name: string | undefined;
-  description?: string;
-  customerEncryptionKeyArn?: string;
-  defaultVariant?: string;
-  variants?: PromptVariant[];
-  clientToken?: string;
-  tags?: Record<string, string>;
-}
-export interface CreatePromptResponse {
-  name: string | undefined;
-  description?: string;
-  customerEncryptionKeyArn?: string;
-  defaultVariant?: string;
-  variants?: PromptVariant[];
-  id: string | undefined;
-  arn: string | undefined;
-  version: string | undefined;
-  createdAt: Date | undefined;
-  updatedAt: Date | undefined;
-}
-export interface CreatePromptVersionRequest {
-  promptIdentifier: string | undefined;
-  description?: string;
-  clientToken?: string;
-  tags?: Record<string, string>;
-}
-export interface CreatePromptVersionResponse {
-  name: string | undefined;
-  description?: string;
-  customerEncryptionKeyArn?: string;
-  defaultVariant?: string;
-  variants?: PromptVariant[];
-  id: string | undefined;
-  arn: string | undefined;
-  version: string | undefined;
-  createdAt: Date | undefined;
-  updatedAt: Date | undefined;
-}
-export interface DeletePromptRequest {
-  promptIdentifier: string | undefined;
-  promptVersion?: string;
-}
-export interface DeletePromptResponse {
-  id: string | undefined;
-  version?: string;
-}
-export interface GetPromptRequest {
-  promptIdentifier: string | undefined;
-  promptVersion?: string;
-}
-export interface GetPromptResponse {
-  name: string | undefined;
-  description?: string;
-  customerEncryptionKeyArn?: string;
-  defaultVariant?: string;
-  variants?: PromptVariant[];
-  id: string | undefined;
-  arn: string | undefined;
-  version: string | undefined;
-  createdAt: Date | undefined;
-  updatedAt: Date | undefined;
-}
-export interface ListPromptsRequest {
-  promptIdentifier?: string;
-  maxResults?: number;
-  nextToken?: string;
-}
-export interface PromptSummary {
-  name: string | undefined;
-  description?: string;
-  id: string | undefined;
-  arn: string | undefined;
-  version: string | undefined;
-  createdAt: Date | undefined;
-  updatedAt: Date | undefined;
-}
-export interface ListPromptsResponse {
-  promptSummaries: PromptSummary[] | undefined;
-  nextToken?: string;
-}
-export interface UpdatePromptRequest {
-  name: string | undefined;
-  description?: string;
-  customerEncryptionKeyArn?: string;
-  defaultVariant?: string;
-  variants?: PromptVariant[];
-  promptIdentifier: string | undefined;
-}
-export interface UpdatePromptResponse {
-  name: string | undefined;
-  description?: string;
-  customerEncryptionKeyArn?: string;
-  defaultVariant?: string;
-  variants?: PromptVariant[];
-  id: string | undefined;
-  arn: string | undefined;
-  version: string | undefined;
-  createdAt: Date | undefined;
-  updatedAt: Date | undefined;
-}
-export interface ListTagsForResourceRequest {
-  resourceArn: string | undefined;
-}
-export interface ListTagsForResourceResponse {
-  tags?: Record<string, string>;
-}
-export interface TagResourceRequest {
-  resourceArn: string | undefined;
-  tags: Record<string, string> | undefined;
-}
-export interface TagResourceResponse {}
-export interface UntagResourceRequest {
-  resourceArn: string | undefined;
-  tagKeys: string[] | undefined;
-}
-export interface UntagResourceResponse {}
-export interface DeleteAgentVersionRequest {
-  agentId: string | undefined;
-  agentVersion: string | undefined;
-  skipResourceInUseCheck?: boolean;
-}
-export interface DeleteAgentVersionResponse {
-  agentId: string | undefined;
-  agentVersion: string | undefined;
-  agentStatus: AgentStatus | undefined;
-}
-export interface GetAgentVersionRequest {
-  agentId: string | undefined;
-  agentVersion: string | undefined;
-}
-export interface GetAgentVersionResponse {
-  agentVersion: AgentVersion | undefined;
-}
-export interface ListAgentVersionsRequest {
-  agentId: string | undefined;
-  maxResults?: number;
-  nextToken?: string;
-}
-export interface ListAgentVersionsResponse {
-  agentVersionSummaries: AgentVersionSummary[] | undefined;
-  nextToken?: string;
-}
 export declare const APISchemaFilterSensitiveLog: (obj: APISchema) => any;
 export declare const CreateAgentActionGroupRequestFilterSensitiveLog: (
   obj: CreateAgentActionGroupRequest
@@ -2164,6 +3050,18 @@ export declare const FlowConditionFilterSensitiveLog: (
 export declare const ConditionFlowNodeConfigurationFilterSensitiveLog: (
   obj: ConditionFlowNodeConfiguration
 ) => any;
+export declare const ContentBlockFilterSensitiveLog: (obj: ContentBlock) => any;
+export declare const MessageFilterSensitiveLog: (obj: Message) => any;
+export declare const SystemContentBlockFilterSensitiveLog: (
+  obj: SystemContentBlock
+) => any;
+export declare const ToolChoiceFilterSensitiveLog: (obj: ToolChoice) => any;
+export declare const ToolConfigurationFilterSensitiveLog: (
+  obj: ToolConfiguration
+) => any;
+export declare const ChatPromptTemplateConfigurationFilterSensitiveLog: (
+  obj: ChatPromptTemplateConfiguration
+) => any;
 export declare const TextPromptTemplateConfigurationFilterSensitiveLog: (
   obj: TextPromptTemplateConfiguration
 ) => any;
@@ -2201,6 +3099,15 @@ export declare const CreateFlowVersionResponseFilterSensitiveLog: (
 export declare const GetFlowVersionResponseFilterSensitiveLog: (
   obj: GetFlowVersionResponse
 ) => any;
+export declare const DuplicateConditionExpressionFlowValidationDetailsFilterSensitiveLog: (
+  obj: DuplicateConditionExpressionFlowValidationDetails
+) => any;
+export declare const FlowValidationDetailsFilterSensitiveLog: (
+  obj: FlowValidationDetails
+) => any;
+export declare const FlowValidationFilterSensitiveLog: (
+  obj: FlowValidation
+) => any;
 export declare const GetFlowResponseFilterSensitiveLog: (
   obj: GetFlowResponse
 ) => any;
@@ -2210,30 +3117,3 @@ export declare const UpdateFlowRequestFilterSensitiveLog: (
 export declare const UpdateFlowResponseFilterSensitiveLog: (
   obj: UpdateFlowResponse
 ) => any;
-export declare const PromptMetadataEntryFilterSensitiveLog: (
-  obj: PromptMetadataEntry
-) => any;
-export declare const PromptVariantFilterSensitiveLog: (
-  obj: PromptVariant
-) => any;
-export declare const CreatePromptRequestFilterSensitiveLog: (
-  obj: CreatePromptRequest
-) => any;
-export declare const CreatePromptResponseFilterSensitiveLog: (
-  obj: CreatePromptResponse
-) => any;
-export declare const CreatePromptVersionResponseFilterSensitiveLog: (
-  obj: CreatePromptVersionResponse
-) => any;
-export declare const GetPromptResponseFilterSensitiveLog: (
-  obj: GetPromptResponse
-) => any;
-export declare const UpdatePromptRequestFilterSensitiveLog: (
-  obj: UpdatePromptRequest
-) => any;
-export declare const UpdatePromptResponseFilterSensitiveLog: (
-  obj: UpdatePromptResponse
-) => any;
-export declare const GetAgentVersionResponseFilterSensitiveLog: (
-  obj: GetAgentVersionResponse
-) => any;