@aws-sdk/client-bedrock-agent 3.808.0 → 3.811.0

package/dist-es/commands/CreateFlowCommand.js

@@ -2,7 +2,7 @@ import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateFlowRequestFilterSensitiveLog, CreateFlowResponseFilterSensitiveLog, } from "../models/models_0";
+import { CreateFlowRequestFilterSensitiveLog, CreateFlowResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_CreateFlowCommand, se_CreateFlowCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class CreateFlowCommand extends $Command

package/dist-es/commands/CreateFlowVersionCommand.js

@@ -2,7 +2,7 @@ import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateFlowVersionResponseFilterSensitiveLog, } from "../models/models_0";
+import { CreateFlowVersionResponseFilterSensitiveLog } from "../models/models_1";
 import { de_CreateFlowVersionCommand, se_CreateFlowVersionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class CreateFlowVersionCommand extends $Command

package/dist-es/commands/GetFlowCommand.js

@@ -2,7 +2,7 @@ import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { GetFlowResponseFilterSensitiveLog } from "../models/models_0";
+import { GetFlowResponseFilterSensitiveLog } from "../models/models_1";
 import { de_GetFlowCommand, se_GetFlowCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class GetFlowCommand extends $Command

package/dist-es/commands/GetFlowVersionCommand.js

@@ -2,7 +2,7 @@ import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { GetFlowVersionResponseFilterSensitiveLog, } from "../models/models_0";
+import { GetFlowVersionResponseFilterSensitiveLog } from "../models/models_1";
 import { de_GetFlowVersionCommand, se_GetFlowVersionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class GetFlowVersionCommand extends $Command

package/dist-es/commands/UpdateFlowCommand.js

@@ -2,7 +2,7 @@ import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { UpdateFlowRequestFilterSensitiveLog, UpdateFlowResponseFilterSensitiveLog, } from "../models/models_0";
+import { UpdateFlowRequestFilterSensitiveLog, UpdateFlowResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_UpdateFlowCommand, se_UpdateFlowCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class UpdateFlowCommand extends $Command

package/dist-es/models/models_0.js

@@ -289,6 +289,27 @@ export var PromptInferenceConfiguration;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(PromptInferenceConfiguration || (PromptInferenceConfiguration = {}));
+export const PerformanceConfigLatency = {
+    OPTIMIZED: "optimized",
+    STANDARD: "standard",
+};
+export const RerankingMetadataSelectionMode = {
+    ALL: "ALL",
+    SELECTIVE: "SELECTIVE",
+};
+export var RerankingMetadataSelectiveModeConfiguration;
+(function (RerankingMetadataSelectiveModeConfiguration) {
+    RerankingMetadataSelectiveModeConfiguration.visit = (value, visitor) => {
+        if (value.fieldsToInclude !== undefined)
+            return visitor.fieldsToInclude(value.fieldsToInclude);
+        if (value.fieldsToExclude !== undefined)
+            return visitor.fieldsToExclude(value.fieldsToExclude);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RerankingMetadataSelectiveModeConfiguration || (RerankingMetadataSelectiveModeConfiguration = {}));
+export const VectorSearchRerankingConfigurationType = {
+    BEDROCK_RERANKING_MODEL: "BEDROCK_RERANKING_MODEL",
+};
 export const CachePointType = {
     DEFAULT: "default",
 };
@@ -386,38 +407,11 @@ export var StorageFlowNodeServiceConfiguration;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(StorageFlowNodeServiceConfiguration || (StorageFlowNodeServiceConfiguration = {}));
-export var FlowNodeConfiguration;
-(function (FlowNodeConfiguration) {
-    FlowNodeConfiguration.visit = (value, visitor) => {
-        if (value.input !== undefined)
-            return visitor.input(value.input);
-        if (value.output !== undefined)
-            return visitor.output(value.output);
-        if (value.knowledgeBase !== undefined)
-            return visitor.knowledgeBase(value.knowledgeBase);
-        if (value.condition !== undefined)
-            return visitor.condition(value.condition);
-        if (value.lex !== undefined)
-            return visitor.lex(value.lex);
-        if (value.prompt !== undefined)
-            return visitor.prompt(value.prompt);
-        if (value.lambdaFunction !== undefined)
-            return visitor.lambdaFunction(value.lambdaFunction);
-        if (value.storage !== undefined)
-            return visitor.storage(value.storage);
-        if (value.agent !== undefined)
-            return visitor.agent(value.agent);
-        if (value.retrieval !== undefined)
-            return visitor.retrieval(value.retrieval);
-        if (value.iterator !== undefined)
-            return visitor.iterator(value.iterator);
-        if (value.collector !== undefined)
-            return visitor.collector(value.collector);
-        if (value.inlineCode !== undefined)
-            return visitor.inlineCode(value.inlineCode);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(FlowNodeConfiguration || (FlowNodeConfiguration = {}));
+export const FlowNodeInputCategory = {
+    EXIT_LOOP: "ExitLoop",
+    LOOP_CONDITION: "LoopCondition",
+    RETURN_VALUE_TO_LOOP_START: "ReturnValueToLoopStart",
+};
 export const FlowNodeIODataType = {
     ARRAY: "Array",
     BOOLEAN: "Boolean",
@@ -435,6 +429,9 @@ export const FlowNodeType = {
     KNOWLEDGE_BASE: "KnowledgeBase",
     LAMBDA_FUNCTION: "LambdaFunction",
     LEX: "Lex",
+    LOOP: "Loop",
+    LOOP_CONTROLLER: "LoopController",
+    LOOP_INPUT: "LoopInput",
     OUTPUT: "Output",
     PROMPT: "Prompt",
     RETRIEVAL: "Retrieval",
@@ -446,6 +443,16 @@ export const FlowStatus = {
     PREPARED: "Prepared",
     PREPARING: "Preparing",
 };
+export const ConcurrencyType = {
+    AUTOMATIC: "Automatic",
+    MANUAL: "Manual",
+};
+export const IncompatibleLoopNodeType = {
+    COLLECTOR: "Collector",
+    CONDITION: "Condition",
+    INPUT: "Input",
+    ITERATOR: "Iterator",
+};
 export var FlowValidationDetails;
 (function (FlowValidationDetails) {
     FlowValidationDetails.visit = (value, visitor) => {
@@ -503,6 +510,18 @@ export var FlowValidationDetails;
             return visitor.unknownNodeInput(value.unknownNodeInput);
         if (value.unknownNodeOutput !== undefined)
             return visitor.unknownNodeOutput(value.unknownNodeOutput);
+        if (value.missingLoopInputNode !== undefined)
+            return visitor.missingLoopInputNode(value.missingLoopInputNode);
+        if (value.missingLoopControllerNode !== undefined)
+            return visitor.missingLoopControllerNode(value.missingLoopControllerNode);
+        if (value.multipleLoopInputNodes !== undefined)
+            return visitor.multipleLoopInputNodes(value.multipleLoopInputNodes);
+        if (value.multipleLoopControllerNodes !== undefined)
+            return visitor.multipleLoopControllerNodes(value.multipleLoopControllerNodes);
+        if (value.loopIncompatibleNodeType !== undefined)
+            return visitor.loopIncompatibleNodeType(value.loopIncompatibleNodeType);
+        if (value.invalidLoopBoundary !== undefined)
+            return visitor.invalidLoopBoundary(value.invalidLoopBoundary);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(FlowValidationDetails || (FlowValidationDetails = {}));
@@ -515,6 +534,8 @@ export const FlowValidationType = {
     DUPLICATE_CONDITION_EXPRESSION: "DuplicateConditionExpression",
     DUPLICATE_CONNECTIONS: "DuplicateConnections",
     INCOMPATIBLE_CONNECTION_DATA_TYPE: "IncompatibleConnectionDataType",
+    INVALID_LOOP_BOUNDARY: "InvalidLoopBoundary",
+    LOOP_INCOMPATIBLE_NODE_TYPE: "LoopIncompatibleNodeType",
     MALFORMED_CONDITION_EXPRESSION: "MalformedConditionExpression",
     MALFORMED_NODE_INPUT_EXPRESSION: "MalformedNodeInputExpression",
     MISMATCHED_NODE_INPUT_TYPE: "MismatchedNodeInputType",
@@ -522,10 +543,14 @@ export const FlowValidationType = {
     MISSING_CONNECTION_CONFIGURATION: "MissingConnectionConfiguration",
     MISSING_DEFAULT_CONDITION: "MissingDefaultCondition",
     MISSING_ENDING_NODES: "MissingEndingNodes",
+    MISSING_LOOP_CONTROLLER_NODE: "MissingLoopControllerNode",
+    MISSING_LOOP_INPUT_NODE: "MissingLoopInputNode",
     MISSING_NODE_CONFIGURATION: "MissingNodeConfiguration",
     MISSING_NODE_INPUT: "MissingNodeInput",
     MISSING_NODE_OUTPUT: "MissingNodeOutput",
     MISSING_STARTING_NODES: "MissingStartingNodes",
+    MULTIPLE_LOOP_CONTROLLER_NODES: "MultipleLoopControllerNodes",
+    MULTIPLE_LOOP_INPUT_NODES: "MultipleLoopInputNodes",
     MULTIPLE_NODE_INPUT_CONNECTIONS: "MultipleNodeInputConnections",
     UNFULFILLED_NODE_INPUT: "UnfulfilledNodeInput",
     UNKNOWN_CONNECTION_CONDITION: "UnknownConnectionCondition",
@@ -547,20 +572,6 @@ export const IngestionJobStatus = {
     STOPPED: "STOPPED",
     STOPPING: "STOPPING",
 };
-export const IngestionJobFilterAttribute = {
-    STATUS: "STATUS",
-};
-export const IngestionJobFilterOperator = {
-    EQ: "EQ",
-};
-export const IngestionJobSortByAttribute = {
-    STARTED_AT: "STARTED_AT",
-    STATUS: "STATUS",
-};
-export const SortOrder = {
-    ASCENDING: "ASCENDING",
-    DESCENDING: "DESCENDING",
-};
 export const APISchemaFilterSensitiveLog = (obj) => {
     if (obj.s3 !== undefined)
         return { s3: obj.s3 };
@@ -803,6 +814,56 @@ export const InlineCodeFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.code && { code: SENSITIVE_STRING }),
 });
+export const KnowledgeBasePromptTemplateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.textPromptTemplate && { textPromptTemplate: SENSITIVE_STRING }),
+});
+export const KnowledgeBaseOrchestrationConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.promptTemplate && { promptTemplate: KnowledgeBasePromptTemplateFilterSensitiveLog(obj.promptTemplate) }),
+    ...(obj.inferenceConfig && { inferenceConfig: obj.inferenceConfig }),
+});
+export const RerankingMetadataSelectiveModeConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.fieldsToInclude !== undefined)
+        return { fieldsToInclude: SENSITIVE_STRING };
+    if (obj.fieldsToExclude !== undefined)
+        return { fieldsToExclude: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const MetadataConfigurationForRerankingFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.selectiveModeConfiguration && {
+        selectiveModeConfiguration: RerankingMetadataSelectiveModeConfigurationFilterSensitiveLog(obj.selectiveModeConfiguration),
+    }),
+});
+export const VectorSearchBedrockRerankingConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.metadataConfiguration && {
+        metadataConfiguration: MetadataConfigurationForRerankingFilterSensitiveLog(obj.metadataConfiguration),
+    }),
+});
+export const VectorSearchRerankingConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.bedrockRerankingConfiguration && {
+        bedrockRerankingConfiguration: VectorSearchBedrockRerankingConfigurationFilterSensitiveLog(obj.bedrockRerankingConfiguration),
+    }),
+});
+export const KnowledgeBaseFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.promptTemplate && { promptTemplate: KnowledgeBasePromptTemplateFilterSensitiveLog(obj.promptTemplate) }),
+    ...(obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }),
+    ...(obj.rerankingConfiguration && {
+        rerankingConfiguration: VectorSearchRerankingConfigurationFilterSensitiveLog(obj.rerankingConfiguration),
+    }),
+    ...(obj.orchestrationConfiguration && {
+        orchestrationConfiguration: KnowledgeBaseOrchestrationConfigurationFilterSensitiveLog(obj.orchestrationConfiguration),
+    }),
+});
+export const LoopControllerFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.continueCondition && { continueCondition: FlowConditionFilterSensitiveLog(obj.continueCondition) }),
+});
 export const ContentBlockFilterSensitiveLog = (obj) => {
     if (obj.text !== undefined)
         return { text: obj.text };
@@ -879,66 +940,10 @@ export const PromptFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
         sourceConfiguration: PromptFlowNodeSourceConfigurationFilterSensitiveLog(obj.sourceConfiguration),
     }),
 });
-export const FlowNodeConfigurationFilterSensitiveLog = (obj) => {
-    if (obj.input !== undefined)
-        return { input: obj.input };
-    if (obj.output !== undefined)
-        return { output: obj.output };
-    if (obj.knowledgeBase !== undefined)
-        return { knowledgeBase: obj.knowledgeBase };
-    if (obj.condition !== undefined)
-        return { condition: ConditionFlowNodeConfigurationFilterSensitiveLog(obj.condition) };
-    if (obj.lex !== undefined)
-        return { lex: obj.lex };
-    if (obj.prompt !== undefined)
-        return { prompt: PromptFlowNodeConfigurationFilterSensitiveLog(obj.prompt) };
-    if (obj.lambdaFunction !== undefined)
-        return { lambdaFunction: obj.lambdaFunction };
-    if (obj.storage !== undefined)
-        return { storage: obj.storage };
-    if (obj.agent !== undefined)
-        return { agent: obj.agent };
-    if (obj.retrieval !== undefined)
-        return { retrieval: obj.retrieval };
-    if (obj.iterator !== undefined)
-        return { iterator: obj.iterator };
-    if (obj.collector !== undefined)
-        return { collector: obj.collector };
-    if (obj.inlineCode !== undefined)
-        return { inlineCode: InlineCodeFlowNodeConfigurationFilterSensitiveLog(obj.inlineCode) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
 export const FlowNodeInputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.expression && { expression: SENSITIVE_STRING }),
 });
-export const FlowNodeFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.configuration && { configuration: FlowNodeConfigurationFilterSensitiveLog(obj.configuration) }),
-    ...(obj.inputs && { inputs: obj.inputs.map((item) => FlowNodeInputFilterSensitiveLog(item)) }),
-});
-export const FlowDefinitionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.nodes && { nodes: obj.nodes.map((item) => FlowNodeFilterSensitiveLog(item)) }),
-    ...(obj.connections && { connections: obj.connections.map((item) => item) }),
-});
-export const CreateFlowRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});
-export const CreateFlowResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});
-export const CreateFlowVersionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});
-export const GetFlowVersionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});
 export const DuplicateConditionExpressionFlowValidationDetailsFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.expression && { expression: SENSITIVE_STRING }),
@@ -1000,6 +1005,18 @@ export const FlowValidationDetailsFilterSensitiveLog = (obj) => {
         return { unknownNodeInput: obj.unknownNodeInput };
     if (obj.unknownNodeOutput !== undefined)
         return { unknownNodeOutput: obj.unknownNodeOutput };
+    if (obj.missingLoopInputNode !== undefined)
+        return { missingLoopInputNode: obj.missingLoopInputNode };
+    if (obj.missingLoopControllerNode !== undefined)
+        return { missingLoopControllerNode: obj.missingLoopControllerNode };
+    if (obj.multipleLoopInputNodes !== undefined)
+        return { multipleLoopInputNodes: obj.multipleLoopInputNodes };
+    if (obj.multipleLoopControllerNodes !== undefined)
+        return { multipleLoopControllerNodes: obj.multipleLoopControllerNodes };
+    if (obj.loopIncompatibleNodeType !== undefined)
+        return { loopIncompatibleNodeType: obj.loopIncompatibleNodeType };
+    if (obj.invalidLoopBoundary !== undefined)
+        return { invalidLoopBoundary: obj.invalidLoopBoundary };
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
@@ -1007,16 +1024,3 @@ export const FlowValidationFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.details && { details: FlowValidationDetailsFilterSensitiveLog(obj.details) }),
 });
-export const GetFlowResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-    ...(obj.validations && { validations: obj.validations.map((item) => FlowValidationFilterSensitiveLog(item)) }),
-});
-export const UpdateFlowRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});
-export const UpdateFlowResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});

package/dist-es/models/models_1.js

@@ -1,5 +1,19 @@
 import { SENSITIVE_STRING } from "@smithy/smithy-client";
-import { AgentVersionFilterSensitiveLog, FlowValidationFilterSensitiveLog, PromptTemplateConfigurationFilterSensitiveLog, } from "./models_0";
+import { AgentVersionFilterSensitiveLog, ConditionFlowNodeConfigurationFilterSensitiveLog, FlowNodeInputFilterSensitiveLog, FlowValidationFilterSensitiveLog, InlineCodeFlowNodeConfigurationFilterSensitiveLog, KnowledgeBaseFlowNodeConfigurationFilterSensitiveLog, LoopControllerFlowNodeConfigurationFilterSensitiveLog, PromptFlowNodeConfigurationFilterSensitiveLog, PromptTemplateConfigurationFilterSensitiveLog, } from "./models_0";
+export const IngestionJobFilterAttribute = {
+    STATUS: "STATUS",
+};
+export const IngestionJobFilterOperator = {
+    EQ: "EQ",
+};
+export const IngestionJobSortByAttribute = {
+    STARTED_AT: "STARTED_AT",
+    STATUS: "STATUS",
+};
+export const SortOrder = {
+    ASCENDING: "ASCENDING",
+    DESCENDING: "DESCENDING",
+};
 export const ContentDataSourceType = {
     CUSTOM: "CUSTOM",
     S3: "S3",
@@ -97,6 +111,44 @@ export var PromptGenAiResource;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(PromptGenAiResource || (PromptGenAiResource = {}));
+export var FlowNodeConfiguration;
+(function (FlowNodeConfiguration) {
+    FlowNodeConfiguration.visit = (value, visitor) => {
+        if (value.input !== undefined)
+            return visitor.input(value.input);
+        if (value.output !== undefined)
+            return visitor.output(value.output);
+        if (value.knowledgeBase !== undefined)
+            return visitor.knowledgeBase(value.knowledgeBase);
+        if (value.condition !== undefined)
+            return visitor.condition(value.condition);
+        if (value.lex !== undefined)
+            return visitor.lex(value.lex);
+        if (value.prompt !== undefined)
+            return visitor.prompt(value.prompt);
+        if (value.lambdaFunction !== undefined)
+            return visitor.lambdaFunction(value.lambdaFunction);
+        if (value.storage !== undefined)
+            return visitor.storage(value.storage);
+        if (value.agent !== undefined)
+            return visitor.agent(value.agent);
+        if (value.retrieval !== undefined)
+            return visitor.retrieval(value.retrieval);
+        if (value.iterator !== undefined)
+            return visitor.iterator(value.iterator);
+        if (value.collector !== undefined)
+            return visitor.collector(value.collector);
+        if (value.inlineCode !== undefined)
+            return visitor.inlineCode(value.inlineCode);
+        if (value.loop !== undefined)
+            return visitor.loop(value.loop);
+        if (value.loopInput !== undefined)
+            return visitor.loopInput(value.loopInput);
+        if (value.loopController !== undefined)
+            return visitor.loopController(value.loopController);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowNodeConfiguration || (FlowNodeConfiguration = {}));
 export const ByteContentDocFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.data && { data: SENSITIVE_STRING }),
@@ -272,10 +324,6 @@ export const UpdatePromptResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.variants && { variants: SENSITIVE_STRING }),
 });
-export const ValidateFlowDefinitionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-});
 export const ValidateFlowDefinitionResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.validations && { validations: obj.validations.map((item) => FlowValidationFilterSensitiveLog(item)) }),
@@ -284,3 +332,86 @@ export const GetAgentVersionResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.agentVersion && { agentVersion: AgentVersionFilterSensitiveLog(obj.agentVersion) }),
 });
+export const FlowDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.nodes && { nodes: obj.nodes.map((item) => FlowNodeFilterSensitiveLog(item)) }),
+    ...(obj.connections && { connections: obj.connections.map((item) => item) }),
+});
+export const FlowNodeFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.configuration && { configuration: FlowNodeConfigurationFilterSensitiveLog(obj.configuration) }),
+    ...(obj.inputs && { inputs: obj.inputs.map((item) => FlowNodeInputFilterSensitiveLog(item)) }),
+});
+export const FlowNodeConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.input !== undefined)
+        return { input: obj.input };
+    if (obj.output !== undefined)
+        return { output: obj.output };
+    if (obj.knowledgeBase !== undefined)
+        return { knowledgeBase: KnowledgeBaseFlowNodeConfigurationFilterSensitiveLog(obj.knowledgeBase) };
+    if (obj.condition !== undefined)
+        return { condition: ConditionFlowNodeConfigurationFilterSensitiveLog(obj.condition) };
+    if (obj.lex !== undefined)
+        return { lex: obj.lex };
+    if (obj.prompt !== undefined)
+        return { prompt: PromptFlowNodeConfigurationFilterSensitiveLog(obj.prompt) };
+    if (obj.lambdaFunction !== undefined)
+        return { lambdaFunction: obj.lambdaFunction };
+    if (obj.storage !== undefined)
+        return { storage: obj.storage };
+    if (obj.agent !== undefined)
+        return { agent: obj.agent };
+    if (obj.retrieval !== undefined)
+        return { retrieval: obj.retrieval };
+    if (obj.iterator !== undefined)
+        return { iterator: obj.iterator };
+    if (obj.collector !== undefined)
+        return { collector: obj.collector };
+    if (obj.inlineCode !== undefined)
+        return { inlineCode: InlineCodeFlowNodeConfigurationFilterSensitiveLog(obj.inlineCode) };
+    if (obj.loop !== undefined)
+        return { loop: LoopFlowNodeConfigurationFilterSensitiveLog(obj.loop) };
+    if (obj.loopInput !== undefined)
+        return { loopInput: obj.loopInput };
+    if (obj.loopController !== undefined)
+        return { loopController: LoopControllerFlowNodeConfigurationFilterSensitiveLog(obj.loopController) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const LoopFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const CreateFlowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const CreateFlowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const CreateFlowVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const GetFlowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+    ...(obj.validations && { validations: obj.validations.map((item) => FlowValidationFilterSensitiveLog(item)) }),
+});
+export const GetFlowVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const UpdateFlowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const UpdateFlowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});
+export const ValidateFlowDefinitionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: SENSITIVE_STRING }),
+});