@aws-sdk/client-bedrock-agent 3.613.0 → 3.614.0

package/dist-es/commands/UpdateFlowAliasCommand.js

@@ -0,0 +1,24 @@
+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 { de_UpdateFlowAliasCommand, se_UpdateFlowAliasCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateFlowAliasCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentBuildTimeLambda", "UpdateFlowAlias", {})
+    .n("BedrockAgentClient", "UpdateFlowAliasCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateFlowAliasCommand)
+    .de(de_UpdateFlowAliasCommand)
+    .build() {
+}

package/dist-es/commands/UpdateFlowCommand.js

@@ -0,0 +1,25 @@
+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 { de_UpdateFlowCommand, se_UpdateFlowCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateFlowCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentBuildTimeLambda", "UpdateFlow", {})
+    .n("BedrockAgentClient", "UpdateFlowCommand")
+    .f(UpdateFlowRequestFilterSensitiveLog, UpdateFlowResponseFilterSensitiveLog)
+    .ser(se_UpdateFlowCommand)
+    .de(de_UpdateFlowCommand)
+    .build() {
+}

package/dist-es/commands/UpdatePromptCommand.js

@@ -0,0 +1,25 @@
+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 { de_UpdatePromptCommand, se_UpdatePromptCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdatePromptCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentBuildTimeLambda", "UpdatePrompt", {})
+    .n("BedrockAgentClient", "UpdatePromptCommand")
+    .f(UpdatePromptRequestFilterSensitiveLog, UpdatePromptResponseFilterSensitiveLog)
+    .ser(se_UpdatePromptCommand)
+    .de(de_UpdatePromptCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -3,13 +3,22 @@ export * from "./CreateAgentActionGroupCommand";
 export * from "./CreateAgentAliasCommand";
 export * from "./CreateAgentCommand";
 export * from "./CreateDataSourceCommand";
+export * from "./CreateFlowAliasCommand";
+export * from "./CreateFlowCommand";
+export * from "./CreateFlowVersionCommand";
 export * from "./CreateKnowledgeBaseCommand";
+export * from "./CreatePromptCommand";
+export * from "./CreatePromptVersionCommand";
 export * from "./DeleteAgentActionGroupCommand";
 export * from "./DeleteAgentAliasCommand";
 export * from "./DeleteAgentCommand";
 export * from "./DeleteAgentVersionCommand";
 export * from "./DeleteDataSourceCommand";
+export * from "./DeleteFlowAliasCommand";
+export * from "./DeleteFlowCommand";
+export * from "./DeleteFlowVersionCommand";
 export * from "./DeleteKnowledgeBaseCommand";
+export * from "./DeletePromptCommand";
 export * from "./DisassociateAgentKnowledgeBaseCommand";
 export * from "./GetAgentActionGroupCommand";
 export * from "./GetAgentAliasCommand";
@@ -17,18 +26,27 @@ export * from "./GetAgentCommand";
 export * from "./GetAgentKnowledgeBaseCommand";
 export * from "./GetAgentVersionCommand";
 export * from "./GetDataSourceCommand";
+export * from "./GetFlowAliasCommand";
+export * from "./GetFlowCommand";
+export * from "./GetFlowVersionCommand";
 export * from "./GetIngestionJobCommand";
 export * from "./GetKnowledgeBaseCommand";
+export * from "./GetPromptCommand";
 export * from "./ListAgentActionGroupsCommand";
 export * from "./ListAgentAliasesCommand";
 export * from "./ListAgentKnowledgeBasesCommand";
 export * from "./ListAgentVersionsCommand";
 export * from "./ListAgentsCommand";
 export * from "./ListDataSourcesCommand";
+export * from "./ListFlowAliasesCommand";
+export * from "./ListFlowVersionsCommand";
+export * from "./ListFlowsCommand";
 export * from "./ListIngestionJobsCommand";
 export * from "./ListKnowledgeBasesCommand";
+export * from "./ListPromptsCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./PrepareAgentCommand";
+export * from "./PrepareFlowCommand";
 export * from "./StartIngestionJobCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
@@ -37,4 +55,7 @@ export * from "./UpdateAgentAliasCommand";
 export * from "./UpdateAgentCommand";
 export * from "./UpdateAgentKnowledgeBaseCommand";
 export * from "./UpdateDataSourceCommand";
+export * from "./UpdateFlowAliasCommand";
+export * from "./UpdateFlowCommand";
 export * from "./UpdateKnowledgeBaseCommand";
+export * from "./UpdatePromptCommand";

package/dist-es/models/models_0.js

@@ -67,6 +67,7 @@ export var FunctionSchema;
     };
 })(FunctionSchema || (FunctionSchema = {}));
 export const ActionGroupSignature = {
+    AMAZON_CODEINTERPRETER: "AMAZON.CodeInterpreter",
     AMAZON_USERINPUT: "AMAZON.UserInput",
 };
 export class InternalServerException extends __BaseException {
@@ -140,6 +141,9 @@ export const AgentStatus = {
     UPDATING: "UPDATING",
     VERSIONING: "VERSIONING",
 };
+export const MemoryType = {
+    SESSION_SUMMARY: "SESSION_SUMMARY",
+};
 export const CreationMode = {
     DEFAULT: "DEFAULT",
     OVERRIDDEN: "OVERRIDDEN",
@@ -169,18 +173,173 @@ export const DataDeletionPolicy = {
     DELETE: "DELETE",
     RETAIN: "RETAIN",
 };
+export const CrawlFilterConfigurationType = {
+    PATTERN: "PATTERN",
+};
+export const ConfluenceAuthType = {
+    BASIC: "BASIC",
+    OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS",
+};
+export const ConfluenceHostType = {
+    SAAS: "SAAS",
+};
+export const SalesforceAuthType = {
+    OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS",
+};
+export const SharePointAuthType = {
+    OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS",
+};
+export const SharePointHostType = {
+    ONLINE: "ONLINE",
+};
 export const DataSourceType = {
+    CONFLUENCE: "CONFLUENCE",
     S3: "S3",
+    SALESFORCE: "SALESFORCE",
+    SHAREPOINT: "SHAREPOINT",
+    WEB: "WEB",
+};
+export const WebScopeType = {
+    HOST_ONLY: "HOST_ONLY",
+    SUBDOMAINS: "SUBDOMAINS",
 };
 export const ChunkingStrategy = {
     FIXED_SIZE: "FIXED_SIZE",
+    HIERARCHICAL: "HIERARCHICAL",
     NONE: "NONE",
+    SEMANTIC: "SEMANTIC",
+};
+export const StepType = {
+    POST_CHUNKING: "POST_CHUNKING",
+};
+export const ParsingStrategy = {
+    BEDROCK_FOUNDATION_MODEL: "BEDROCK_FOUNDATION_MODEL",
 };
 export const DataSourceStatus = {
     AVAILABLE: "AVAILABLE",
     DELETE_UNSUCCESSFUL: "DELETE_UNSUCCESSFUL",
     DELETING: "DELETING",
 };
+export var FlowConnectionConfiguration;
+(function (FlowConnectionConfiguration) {
+    FlowConnectionConfiguration.visit = (value, visitor) => {
+        if (value.data !== undefined)
+            return visitor.data(value.data);
+        if (value.conditional !== undefined)
+            return visitor.conditional(value.conditional);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowConnectionConfiguration || (FlowConnectionConfiguration = {}));
+export const FlowConnectionType = {
+    CONDITIONAL: "Conditional",
+    DATA: "Data",
+};
+export var PromptInferenceConfiguration;
+(function (PromptInferenceConfiguration) {
+    PromptInferenceConfiguration.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PromptInferenceConfiguration || (PromptInferenceConfiguration = {}));
+export var PromptTemplateConfiguration;
+(function (PromptTemplateConfiguration) {
+    PromptTemplateConfiguration.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PromptTemplateConfiguration || (PromptTemplateConfiguration = {}));
+export const PromptTemplateType = {
+    TEXT: "TEXT",
+};
+export var PromptFlowNodeSourceConfiguration;
+(function (PromptFlowNodeSourceConfiguration) {
+    PromptFlowNodeSourceConfiguration.visit = (value, visitor) => {
+        if (value.resource !== undefined)
+            return visitor.resource(value.resource);
+        if (value.inline !== undefined)
+            return visitor.inline(value.inline);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PromptFlowNodeSourceConfiguration || (PromptFlowNodeSourceConfiguration = {}));
+export var RetrievalFlowNodeServiceConfiguration;
+(function (RetrievalFlowNodeServiceConfiguration) {
+    RetrievalFlowNodeServiceConfiguration.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RetrievalFlowNodeServiceConfiguration || (RetrievalFlowNodeServiceConfiguration = {}));
+export var StorageFlowNodeServiceConfiguration;
+(function (StorageFlowNodeServiceConfiguration) {
+    StorageFlowNodeServiceConfiguration.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        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);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowNodeConfiguration || (FlowNodeConfiguration = {}));
+export const FlowNodeIODataType = {
+    ARRAY: "Array",
+    BOOLEAN: "Boolean",
+    NUMBER: "Number",
+    OBJECT: "Object",
+    STRING: "String",
+};
+export const FlowNodeType = {
+    AGENT: "Agent",
+    COLLECTOR: "Collector",
+    CONDITION: "Condition",
+    INPUT: "Input",
+    ITERATOR: "Iterator",
+    KNOWLEDGE_BASE: "KnowledgeBase",
+    LAMBDA_FUNCTION: "LambdaFunction",
+    LEX: "Lex",
+    OUTPUT: "Output",
+    PROMPT: "Prompt",
+    RETRIEVAL: "Retrieval",
+    STORAGE: "Storage",
+};
+export const FlowStatus = {
+    FAILED: "Failed",
+    NOT_PREPARED: "NotPrepared",
+    PREPARED: "Prepared",
+    PREPARING: "Preparing",
+};
+export const FlowValidationSeverity = {
+    ERROR: "Error",
+    WARNING: "Warning",
+};
 export const IngestionJobStatus = {
     COMPLETE: "COMPLETE",
     FAILED: "FAILED",
@@ -257,8 +416,15 @@ export const UpdateAgentActionGroupResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.agentActionGroup && { agentActionGroup: AgentActionGroupFilterSensitiveLog(obj.agentActionGroup) }),
 });
+export const PromptConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.basePromptTemplate && { basePromptTemplate: SENSITIVE_STRING }),
+});
 export const PromptOverrideConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
+    ...(obj.promptConfigurations && {
+        promptConfigurations: obj.promptConfigurations.map((item) => PromptConfigurationFilterSensitiveLog(item)),
+    }),
 });
 export const AgentFilterSensitiveLog = (obj) => ({
     ...obj,
@@ -292,6 +458,258 @@ export const AgentVersionFilterSensitiveLog = (obj) => ({
     ...(obj.instruction && { instruction: SENSITIVE_STRING }),
     ...(obj.promptOverrideConfiguration && { promptOverrideConfiguration: SENSITIVE_STRING }),
 });
+export const PatternObjectFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.objectType && { objectType: SENSITIVE_STRING }),
+    ...(obj.inclusionFilters && { inclusionFilters: SENSITIVE_STRING }),
+    ...(obj.exclusionFilters && { exclusionFilters: SENSITIVE_STRING }),
+});
+export const PatternObjectFilterConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filters && { filters: SENSITIVE_STRING }),
+});
+export const CrawlFilterConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.patternObjectFilter && {
+        patternObjectFilter: PatternObjectFilterConfigurationFilterSensitiveLog(obj.patternObjectFilter),
+    }),
+});
+export const ConfluenceCrawlerConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filterConfiguration && {
+        filterConfiguration: CrawlFilterConfigurationFilterSensitiveLog(obj.filterConfiguration),
+    }),
+});
+export const ConfluenceDataSourceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.crawlerConfiguration && {
+        crawlerConfiguration: ConfluenceCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration),
+    }),
+});
+export const S3DataSourceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.inclusionPrefixes && { inclusionPrefixes: SENSITIVE_STRING }),
+});
+export const SalesforceCrawlerConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filterConfiguration && {
+        filterConfiguration: CrawlFilterConfigurationFilterSensitiveLog(obj.filterConfiguration),
+    }),
+});
+export const SalesforceDataSourceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.crawlerConfiguration && {
+        crawlerConfiguration: SalesforceCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration),
+    }),
+});
+export const SharePointCrawlerConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filterConfiguration && {
+        filterConfiguration: CrawlFilterConfigurationFilterSensitiveLog(obj.filterConfiguration),
+    }),
+});
+export const SharePointDataSourceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.crawlerConfiguration && {
+        crawlerConfiguration: SharePointCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration),
+    }),
+});
+export const WebCrawlerConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.inclusionFilters && { inclusionFilters: SENSITIVE_STRING }),
+    ...(obj.exclusionFilters && { exclusionFilters: SENSITIVE_STRING }),
+});
+export const WebDataSourceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.crawlerConfiguration && {
+        crawlerConfiguration: WebCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration),
+    }),
+});
+export const DataSourceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.s3Configuration && { s3Configuration: S3DataSourceConfigurationFilterSensitiveLog(obj.s3Configuration) }),
+    ...(obj.webConfiguration && { webConfiguration: WebDataSourceConfigurationFilterSensitiveLog(obj.webConfiguration) }),
+    ...(obj.confluenceConfiguration && {
+        confluenceConfiguration: ConfluenceDataSourceConfigurationFilterSensitiveLog(obj.confluenceConfiguration),
+    }),
+    ...(obj.salesforceConfiguration && {
+        salesforceConfiguration: SalesforceDataSourceConfigurationFilterSensitiveLog(obj.salesforceConfiguration),
+    }),
+    ...(obj.sharePointConfiguration && {
+        sharePointConfiguration: SharePointDataSourceConfigurationFilterSensitiveLog(obj.sharePointConfiguration),
+    }),
+});
+export const CreateDataSourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.dataSourceConfiguration && {
+        dataSourceConfiguration: DataSourceConfigurationFilterSensitiveLog(obj.dataSourceConfiguration),
+    }),
+});
+export const DataSourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.dataSourceConfiguration && {
+        dataSourceConfiguration: DataSourceConfigurationFilterSensitiveLog(obj.dataSourceConfiguration),
+    }),
+});
+export const CreateDataSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.dataSource && { dataSource: DataSourceFilterSensitiveLog(obj.dataSource) }),
+});
+export const GetDataSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.dataSource && { dataSource: DataSourceFilterSensitiveLog(obj.dataSource) }),
+});
+export const UpdateDataSourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.dataSourceConfiguration && {
+        dataSourceConfiguration: DataSourceConfigurationFilterSensitiveLog(obj.dataSourceConfiguration),
+    }),
+});
+export const UpdateDataSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.dataSource && { dataSource: DataSourceFilterSensitiveLog(obj.dataSource) }),
+});
+export const FlowConditionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.expression && { expression: SENSITIVE_STRING }),
+});
+export const ConditionFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.conditions && { conditions: SENSITIVE_STRING }),
+});
+export const TextPromptTemplateConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+    ...(obj.inputVariables && { inputVariables: SENSITIVE_STRING }),
+});
+export const PromptTemplateConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PromptFlowNodeInlineConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.templateConfiguration && {
+        templateConfiguration: PromptTemplateConfigurationFilterSensitiveLog(obj.templateConfiguration),
+    }),
+    ...(obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }),
+});
+export const PromptFlowNodeSourceConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.resource !== undefined)
+        return { resource: obj.resource };
+    if (obj.inline !== undefined)
+        return { inline: PromptFlowNodeInlineConfigurationFilterSensitiveLog(obj.inline) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PromptFlowNodeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sourceConfiguration && {
+        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.$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: SENSITIVE_STRING }),
+    ...(obj.connections && { connections: obj.connections.map((item) => item) }),
+});
+export const CreateFlowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const CreateFlowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const CreateFlowVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const GetFlowVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const GetFlowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const UpdateFlowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const UpdateFlowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }),
+});
+export const PromptVariantFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.templateConfiguration && {
+        templateConfiguration: PromptTemplateConfigurationFilterSensitiveLog(obj.templateConfiguration),
+    }),
+    ...(obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }),
+});
+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/pagination/ListFlowAliasesPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListFlowAliasesCommand, } from "../commands/ListFlowAliasesCommand";
+export const paginateListFlowAliases = createPaginator(BedrockAgentClient, ListFlowAliasesCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListFlowVersionsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListFlowVersionsCommand, } from "../commands/ListFlowVersionsCommand";
+export const paginateListFlowVersions = createPaginator(BedrockAgentClient, ListFlowVersionsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListFlowsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListFlowsCommand } from "../commands/ListFlowsCommand";
+export const paginateListFlows = createPaginator(BedrockAgentClient, ListFlowsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListPromptsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListPromptsCommand } from "../commands/ListPromptsCommand";
+export const paginateListPrompts = createPaginator(BedrockAgentClient, ListPromptsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/index.js

@@ -5,5 +5,9 @@ export * from "./ListAgentKnowledgeBasesPaginator";
 export * from "./ListAgentVersionsPaginator";
 export * from "./ListAgentsPaginator";
 export * from "./ListDataSourcesPaginator";
+export * from "./ListFlowAliasesPaginator";
+export * from "./ListFlowVersionsPaginator";
+export * from "./ListFlowsPaginator";
 export * from "./ListIngestionJobsPaginator";
 export * from "./ListKnowledgeBasesPaginator";
+export * from "./ListPromptsPaginator";