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

package/dist-es/BedrockAgent.js

@@ -62,6 +62,7 @@ import { UpdateFlowAliasCommand, } from "./commands/UpdateFlowAliasCommand";
 import { UpdateFlowCommand } from "./commands/UpdateFlowCommand";
 import { UpdateKnowledgeBaseCommand, } from "./commands/UpdateKnowledgeBaseCommand";
 import { UpdatePromptCommand, } from "./commands/UpdatePromptCommand";
+import { ValidateFlowDefinitionCommand, } from "./commands/ValidateFlowDefinitionCommand";
 const commands = {
     AssociateAgentKnowledgeBaseCommand,
     CreateAgentCommand,
@@ -125,6 +126,7 @@ const commands = {
     UpdateFlowAliasCommand,
     UpdateKnowledgeBaseCommand,
     UpdatePromptCommand,
+    ValidateFlowDefinitionCommand,
 };
 export class BedrockAgent extends BedrockAgentClient {
 }

package/dist-es/commands/CreatePromptCommand.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 { CreatePromptRequestFilterSensitiveLog, CreatePromptResponseFilterSensitiveLog, } from "../models/models_0";
+import { CreatePromptRequestFilterSensitiveLog, CreatePromptResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_CreatePromptCommand, se_CreatePromptCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class CreatePromptCommand extends $Command

package/dist-es/commands/CreatePromptVersionCommand.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 { CreatePromptVersionResponseFilterSensitiveLog, } from "../models/models_0";
+import { CreatePromptVersionResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_CreatePromptVersionCommand, se_CreatePromptVersionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class CreatePromptVersionCommand extends $Command

package/dist-es/commands/GetAgentVersionCommand.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 { GetAgentVersionResponseFilterSensitiveLog, } from "../models/models_0";
+import { GetAgentVersionResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_GetAgentVersionCommand, se_GetAgentVersionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class GetAgentVersionCommand extends $Command

package/dist-es/commands/GetPromptCommand.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 { GetPromptResponseFilterSensitiveLog } from "../models/models_0";
+import { GetPromptResponseFilterSensitiveLog } from "../models/models_1";
 import { de_GetPromptCommand, se_GetPromptCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class GetPromptCommand extends $Command

package/dist-es/commands/UpdatePromptCommand.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 { UpdatePromptRequestFilterSensitiveLog, UpdatePromptResponseFilterSensitiveLog, } from "../models/models_0";
+import { UpdatePromptRequestFilterSensitiveLog, UpdatePromptResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_UpdatePromptCommand, se_UpdatePromptCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class UpdatePromptCommand extends $Command

package/dist-es/commands/ValidateFlowDefinitionCommand.js

@@ -0,0 +1,23 @@
+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 { ValidateFlowDefinitionRequestFilterSensitiveLog, ValidateFlowDefinitionResponseFilterSensitiveLog, } from "../models/models_1";
+import { de_ValidateFlowDefinitionCommand, se_ValidateFlowDefinitionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ValidateFlowDefinitionCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentBuildTimeLambda", "ValidateFlowDefinition", {})
+    .n("BedrockAgentClient", "ValidateFlowDefinitionCommand")
+    .f(ValidateFlowDefinitionRequestFilterSensitiveLog, ValidateFlowDefinitionResponseFilterSensitiveLog)
+    .ser(se_ValidateFlowDefinitionCommand)
+    .de(de_ValidateFlowDefinitionCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -60,3 +60,4 @@ export * from "./UpdateFlowAliasCommand";
 export * from "./UpdateFlowCommand";
 export * from "./UpdateKnowledgeBaseCommand";
 export * from "./UpdatePromptCommand";
+export * from "./ValidateFlowDefinitionCommand";

package/dist-es/models/index.js

@@ -1 +1,2 @@
 export * from "./models_0";
+export * from "./models_1";

package/dist-es/models/models_0.js

@@ -246,15 +246,66 @@ export var PromptInferenceConfiguration;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(PromptInferenceConfiguration || (PromptInferenceConfiguration = {}));
+export var ContentBlock;
+(function (ContentBlock) {
+    ContentBlock.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ContentBlock || (ContentBlock = {}));
+export const ConversationRole = {
+    ASSISTANT: "assistant",
+    USER: "user",
+};
+export var SystemContentBlock;
+(function (SystemContentBlock) {
+    SystemContentBlock.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SystemContentBlock || (SystemContentBlock = {}));
+export var ToolChoice;
+(function (ToolChoice) {
+    ToolChoice.visit = (value, visitor) => {
+        if (value.auto !== undefined)
+            return visitor.auto(value.auto);
+        if (value.any !== undefined)
+            return visitor.any(value.any);
+        if (value.tool !== undefined)
+            return visitor.tool(value.tool);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolChoice || (ToolChoice = {}));
+export var ToolInputSchema;
+(function (ToolInputSchema) {
+    ToolInputSchema.visit = (value, visitor) => {
+        if (value.json !== undefined)
+            return visitor.json(value.json);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolInputSchema || (ToolInputSchema = {}));
+export var Tool;
+(function (Tool) {
+    Tool.visit = (value, visitor) => {
+        if (value.toolSpec !== undefined)
+            return visitor.toolSpec(value.toolSpec);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Tool || (Tool = {}));
 export var PromptTemplateConfiguration;
 (function (PromptTemplateConfiguration) {
     PromptTemplateConfiguration.visit = (value, visitor) => {
         if (value.text !== undefined)
             return visitor.text(value.text);
+        if (value.chat !== undefined)
+            return visitor.chat(value.chat);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(PromptTemplateConfiguration || (PromptTemplateConfiguration = {}));
 export const PromptTemplateType = {
+    CHAT: "CHAT",
     TEXT: "TEXT",
 };
 export var PromptFlowNodeSourceConfiguration;
@@ -340,10 +391,93 @@ export const FlowStatus = {
     PREPARED: "Prepared",
     PREPARING: "Preparing",
 };
+export var FlowValidationDetails;
+(function (FlowValidationDetails) {
+    FlowValidationDetails.visit = (value, visitor) => {
+        if (value.cyclicConnection !== undefined)
+            return visitor.cyclicConnection(value.cyclicConnection);
+        if (value.duplicateConnections !== undefined)
+            return visitor.duplicateConnections(value.duplicateConnections);
+        if (value.duplicateConditionExpression !== undefined)
+            return visitor.duplicateConditionExpression(value.duplicateConditionExpression);
+        if (value.unreachableNode !== undefined)
+            return visitor.unreachableNode(value.unreachableNode);
+        if (value.unknownConnectionSource !== undefined)
+            return visitor.unknownConnectionSource(value.unknownConnectionSource);
+        if (value.unknownConnectionSourceOutput !== undefined)
+            return visitor.unknownConnectionSourceOutput(value.unknownConnectionSourceOutput);
+        if (value.unknownConnectionTarget !== undefined)
+            return visitor.unknownConnectionTarget(value.unknownConnectionTarget);
+        if (value.unknownConnectionTargetInput !== undefined)
+            return visitor.unknownConnectionTargetInput(value.unknownConnectionTargetInput);
+        if (value.unknownConnectionCondition !== undefined)
+            return visitor.unknownConnectionCondition(value.unknownConnectionCondition);
+        if (value.malformedConditionExpression !== undefined)
+            return visitor.malformedConditionExpression(value.malformedConditionExpression);
+        if (value.malformedNodeInputExpression !== undefined)
+            return visitor.malformedNodeInputExpression(value.malformedNodeInputExpression);
+        if (value.mismatchedNodeInputType !== undefined)
+            return visitor.mismatchedNodeInputType(value.mismatchedNodeInputType);
+        if (value.mismatchedNodeOutputType !== undefined)
+            return visitor.mismatchedNodeOutputType(value.mismatchedNodeOutputType);
+        if (value.incompatibleConnectionDataType !== undefined)
+            return visitor.incompatibleConnectionDataType(value.incompatibleConnectionDataType);
+        if (value.missingConnectionConfiguration !== undefined)
+            return visitor.missingConnectionConfiguration(value.missingConnectionConfiguration);
+        if (value.missingDefaultCondition !== undefined)
+            return visitor.missingDefaultCondition(value.missingDefaultCondition);
+        if (value.missingEndingNodes !== undefined)
+            return visitor.missingEndingNodes(value.missingEndingNodes);
+        if (value.missingNodeConfiguration !== undefined)
+            return visitor.missingNodeConfiguration(value.missingNodeConfiguration);
+        if (value.missingNodeInput !== undefined)
+            return visitor.missingNodeInput(value.missingNodeInput);
+        if (value.missingNodeOutput !== undefined)
+            return visitor.missingNodeOutput(value.missingNodeOutput);
+        if (value.missingStartingNodes !== undefined)
+            return visitor.missingStartingNodes(value.missingStartingNodes);
+        if (value.multipleNodeInputConnections !== undefined)
+            return visitor.multipleNodeInputConnections(value.multipleNodeInputConnections);
+        if (value.unfulfilledNodeInput !== undefined)
+            return visitor.unfulfilledNodeInput(value.unfulfilledNodeInput);
+        if (value.unsatisfiedConnectionConditions !== undefined)
+            return visitor.unsatisfiedConnectionConditions(value.unsatisfiedConnectionConditions);
+        if (value.unspecified !== undefined)
+            return visitor.unspecified(value.unspecified);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowValidationDetails || (FlowValidationDetails = {}));
 export const FlowValidationSeverity = {
     ERROR: "Error",
     WARNING: "Warning",
 };
+export const FlowValidationType = {
+    CYCLIC_CONNECTION: "CyclicConnection",
+    DUPLICATE_CONDITION_EXPRESSION: "DuplicateConditionExpression",
+    DUPLICATE_CONNECTIONS: "DuplicateConnections",
+    INCOMPATIBLE_CONNECTION_DATA_TYPE: "IncompatibleConnectionDataType",
+    MALFORMED_CONDITION_EXPRESSION: "MalformedConditionExpression",
+    MALFORMED_NODE_INPUT_EXPRESSION: "MalformedNodeInputExpression",
+    MISMATCHED_NODE_INPUT_TYPE: "MismatchedNodeInputType",
+    MISMATCHED_NODE_OUTPUT_TYPE: "MismatchedNodeOutputType",
+    MISSING_CONNECTION_CONFIGURATION: "MissingConnectionConfiguration",
+    MISSING_DEFAULT_CONDITION: "MissingDefaultCondition",
+    MISSING_ENDING_NODES: "MissingEndingNodes",
+    MISSING_NODE_CONFIGURATION: "MissingNodeConfiguration",
+    MISSING_NODE_INPUT: "MissingNodeInput",
+    MISSING_NODE_OUTPUT: "MissingNodeOutput",
+    MISSING_STARTING_NODES: "MissingStartingNodes",
+    MULTIPLE_NODE_INPUT_CONNECTIONS: "MultipleNodeInputConnections",
+    UNFULFILLED_NODE_INPUT: "UnfulfilledNodeInput",
+    UNKNOWN_CONNECTION_CONDITION: "UnknownConnectionCondition",
+    UNKNOWN_CONNECTION_SOURCE: "UnknownConnectionSource",
+    UNKNOWN_CONNECTION_SOURCE_OUTPUT: "UnknownConnectionSourceOutput",
+    UNKNOWN_CONNECTION_TARGET: "UnknownConnectionTarget",
+    UNKNOWN_CONNECTION_TARGET_INPUT: "UnknownConnectionTargetInput",
+    UNREACHABLE_NODE: "UnreachableNode",
+    UNSATISFIED_CONNECTION_CONDITIONS: "UnsatisfiedConnectionConditions",
+    UNSPECIFIED: "Unspecified",
+};
 export const IngestionJobStatus = {
     COMPLETE: "COMPLETE",
     FAILED: "FAILED",
@@ -583,6 +717,44 @@ export const ConditionFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.conditions && { conditions: obj.conditions.map((item) => FlowConditionFilterSensitiveLog(item)) }),
 });
+export const ContentBlockFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: obj.text };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const MessageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING }),
+});
+export const SystemContentBlockFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: obj.text };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ToolChoiceFilterSensitiveLog = (obj) => {
+    if (obj.auto !== undefined)
+        return { auto: obj.auto };
+    if (obj.any !== undefined)
+        return { any: obj.any };
+    if (obj.tool !== undefined)
+        return { tool: obj.tool };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ToolConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tools && { tools: SENSITIVE_STRING }),
+    ...(obj.toolChoice && { toolChoice: SENSITIVE_STRING }),
+});
+export const ChatPromptTemplateConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
+    ...(obj.system && { system: SENSITIVE_STRING }),
+    ...(obj.inputVariables && { inputVariables: SENSITIVE_STRING }),
+    ...(obj.toolConfiguration && { toolConfiguration: ToolConfigurationFilterSensitiveLog(obj.toolConfiguration) }),
+});
 export const TextPromptTemplateConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.text && { text: SENSITIVE_STRING }),
@@ -591,6 +763,8 @@ export const TextPromptTemplateConfigurationFilterSensitiveLog = (obj) => ({
 export const PromptTemplateConfigurationFilterSensitiveLog = (obj) => {
     if (obj.text !== undefined)
         return { text: SENSITIVE_STRING };
+    if (obj.chat !== undefined)
+        return { chat: SENSITIVE_STRING };
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
@@ -673,9 +847,74 @@ export const GetFlowVersionResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.definition && { definition: SENSITIVE_STRING }),
 });
+export const DuplicateConditionExpressionFlowValidationDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.expression && { expression: SENSITIVE_STRING }),
+});
+export const FlowValidationDetailsFilterSensitiveLog = (obj) => {
+    if (obj.cyclicConnection !== undefined)
+        return { cyclicConnection: obj.cyclicConnection };
+    if (obj.duplicateConnections !== undefined)
+        return { duplicateConnections: obj.duplicateConnections };
+    if (obj.duplicateConditionExpression !== undefined)
+        return {
+            duplicateConditionExpression: DuplicateConditionExpressionFlowValidationDetailsFilterSensitiveLog(obj.duplicateConditionExpression),
+        };
+    if (obj.unreachableNode !== undefined)
+        return { unreachableNode: obj.unreachableNode };
+    if (obj.unknownConnectionSource !== undefined)
+        return { unknownConnectionSource: obj.unknownConnectionSource };
+    if (obj.unknownConnectionSourceOutput !== undefined)
+        return { unknownConnectionSourceOutput: obj.unknownConnectionSourceOutput };
+    if (obj.unknownConnectionTarget !== undefined)
+        return { unknownConnectionTarget: obj.unknownConnectionTarget };
+    if (obj.unknownConnectionTargetInput !== undefined)
+        return { unknownConnectionTargetInput: obj.unknownConnectionTargetInput };
+    if (obj.unknownConnectionCondition !== undefined)
+        return { unknownConnectionCondition: obj.unknownConnectionCondition };
+    if (obj.malformedConditionExpression !== undefined)
+        return { malformedConditionExpression: obj.malformedConditionExpression };
+    if (obj.malformedNodeInputExpression !== undefined)
+        return { malformedNodeInputExpression: obj.malformedNodeInputExpression };
+    if (obj.mismatchedNodeInputType !== undefined)
+        return { mismatchedNodeInputType: obj.mismatchedNodeInputType };
+    if (obj.mismatchedNodeOutputType !== undefined)
+        return { mismatchedNodeOutputType: obj.mismatchedNodeOutputType };
+    if (obj.incompatibleConnectionDataType !== undefined)
+        return { incompatibleConnectionDataType: obj.incompatibleConnectionDataType };
+    if (obj.missingConnectionConfiguration !== undefined)
+        return { missingConnectionConfiguration: obj.missingConnectionConfiguration };
+    if (obj.missingDefaultCondition !== undefined)
+        return { missingDefaultCondition: obj.missingDefaultCondition };
+    if (obj.missingEndingNodes !== undefined)
+        return { missingEndingNodes: obj.missingEndingNodes };
+    if (obj.missingNodeConfiguration !== undefined)
+        return { missingNodeConfiguration: obj.missingNodeConfiguration };
+    if (obj.missingNodeInput !== undefined)
+        return { missingNodeInput: obj.missingNodeInput };
+    if (obj.missingNodeOutput !== undefined)
+        return { missingNodeOutput: obj.missingNodeOutput };
+    if (obj.missingStartingNodes !== undefined)
+        return { missingStartingNodes: obj.missingStartingNodes };
+    if (obj.multipleNodeInputConnections !== undefined)
+        return { multipleNodeInputConnections: obj.multipleNodeInputConnections };
+    if (obj.unfulfilledNodeInput !== undefined)
+        return { unfulfilledNodeInput: obj.unfulfilledNodeInput };
+    if (obj.unsatisfiedConnectionConditions !== undefined)
+        return { unsatisfiedConnectionConditions: obj.unsatisfiedConnectionConditions };
+    if (obj.unspecified !== undefined)
+        return { unspecified: obj.unspecified };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+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,
@@ -685,44 +924,3 @@ export const UpdateFlowResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.definition && { definition: SENSITIVE_STRING }),
 });
-export const PromptMetadataEntryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.key && { key: SENSITIVE_STRING }),
-    ...(obj.value && { value: SENSITIVE_STRING }),
-});
-export const PromptVariantFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.templateConfiguration && {
-        templateConfiguration: PromptTemplateConfigurationFilterSensitiveLog(obj.templateConfiguration),
-    }),
-    ...(obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }),
-    ...(obj.metadata && { metadata: SENSITIVE_STRING }),
-});
-export const CreatePromptRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.variants && { variants: SENSITIVE_STRING }),
-});
-export const CreatePromptResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.variants && { variants: SENSITIVE_STRING }),
-});
-export const CreatePromptVersionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.variants && { variants: SENSITIVE_STRING }),
-});
-export const GetPromptResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.variants && { variants: SENSITIVE_STRING }),
-});
-export const UpdatePromptRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.variants && { variants: SENSITIVE_STRING }),
-});
-export const UpdatePromptResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.variants && { variants: SENSITIVE_STRING }),
-});
-export const GetAgentVersionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.agentVersion && { agentVersion: AgentVersionFilterSensitiveLog(obj.agentVersion) }),
-});

package/dist-es/models/models_1.js

@@ -0,0 +1,69 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { AgentVersionFilterSensitiveLog, FlowValidationFilterSensitiveLog, PromptTemplateConfigurationFilterSensitiveLog, } from "./models_0";
+export var PromptGenAiResource;
+(function (PromptGenAiResource) {
+    PromptGenAiResource.visit = (value, visitor) => {
+        if (value.agent !== undefined)
+            return visitor.agent(value.agent);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PromptGenAiResource || (PromptGenAiResource = {}));
+export const PromptAgentResourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PromptGenAiResourceFilterSensitiveLog = (obj) => {
+    if (obj.agent !== undefined)
+        return { agent: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PromptMetadataEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.key && { key: SENSITIVE_STRING }),
+    ...(obj.value && { value: SENSITIVE_STRING }),
+});
+export const PromptVariantFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.templateConfiguration && {
+        templateConfiguration: PromptTemplateConfigurationFilterSensitiveLog(obj.templateConfiguration),
+    }),
+    ...(obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }),
+    ...(obj.metadata && { metadata: SENSITIVE_STRING }),
+    ...(obj.genAiResource && { genAiResource: SENSITIVE_STRING }),
+});
+export const CreatePromptRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variants && { variants: SENSITIVE_STRING }),
+});
+export const CreatePromptResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variants && { variants: SENSITIVE_STRING }),
+});
+export const CreatePromptVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variants && { variants: SENSITIVE_STRING }),
+});
+export const GetPromptResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variants && { variants: SENSITIVE_STRING }),
+});
+export const UpdatePromptRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variants && { variants: SENSITIVE_STRING }),
+});
+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)) }),
+});
+export const GetAgentVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentVersion && { agentVersion: AgentVersionFilterSensitiveLog(obj.agentVersion) }),
+});