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

package/dist-cjs/index.js

@@ -37,7 +37,14 @@ __export(src_exports, {
   BedrockAgentClient: () => BedrockAgentClient,
   BedrockAgentServiceException: () => BedrockAgentServiceException,
   ChunkingStrategy: () => ChunkingStrategy,
+  ConditionFlowNodeConfigurationFilterSensitiveLog: () => ConditionFlowNodeConfigurationFilterSensitiveLog,
   ConflictException: () => ConflictException,
+  ConfluenceAuthType: () => ConfluenceAuthType,
+  ConfluenceCrawlerConfigurationFilterSensitiveLog: () => ConfluenceCrawlerConfigurationFilterSensitiveLog,
+  ConfluenceDataSourceConfigurationFilterSensitiveLog: () => ConfluenceDataSourceConfigurationFilterSensitiveLog,
+  ConfluenceHostType: () => ConfluenceHostType,
+  CrawlFilterConfigurationFilterSensitiveLog: () => CrawlFilterConfigurationFilterSensitiveLog,
+  CrawlFilterConfigurationType: () => CrawlFilterConfigurationType,
   CreateAgentActionGroupCommand: () => CreateAgentActionGroupCommand,
   CreateAgentActionGroupRequestFilterSensitiveLog: () => CreateAgentActionGroupRequestFilterSensitiveLog,
   CreateAgentActionGroupResponseFilterSensitiveLog: () => CreateAgentActionGroupResponseFilterSensitiveLog,
@@ -46,10 +53,25 @@ __export(src_exports, {
   CreateAgentRequestFilterSensitiveLog: () => CreateAgentRequestFilterSensitiveLog,
   CreateAgentResponseFilterSensitiveLog: () => CreateAgentResponseFilterSensitiveLog,
   CreateDataSourceCommand: () => CreateDataSourceCommand,
+  CreateDataSourceRequestFilterSensitiveLog: () => CreateDataSourceRequestFilterSensitiveLog,
+  CreateDataSourceResponseFilterSensitiveLog: () => CreateDataSourceResponseFilterSensitiveLog,
+  CreateFlowAliasCommand: () => CreateFlowAliasCommand,
+  CreateFlowCommand: () => CreateFlowCommand,
+  CreateFlowRequestFilterSensitiveLog: () => CreateFlowRequestFilterSensitiveLog,
+  CreateFlowResponseFilterSensitiveLog: () => CreateFlowResponseFilterSensitiveLog,
+  CreateFlowVersionCommand: () => CreateFlowVersionCommand,
+  CreateFlowVersionResponseFilterSensitiveLog: () => CreateFlowVersionResponseFilterSensitiveLog,
   CreateKnowledgeBaseCommand: () => CreateKnowledgeBaseCommand,
+  CreatePromptCommand: () => CreatePromptCommand,
+  CreatePromptRequestFilterSensitiveLog: () => CreatePromptRequestFilterSensitiveLog,
+  CreatePromptResponseFilterSensitiveLog: () => CreatePromptResponseFilterSensitiveLog,
+  CreatePromptVersionCommand: () => CreatePromptVersionCommand,
+  CreatePromptVersionResponseFilterSensitiveLog: () => CreatePromptVersionResponseFilterSensitiveLog,
   CreationMode: () => CreationMode,
   CustomControlMethod: () => CustomControlMethod,
   DataDeletionPolicy: () => DataDeletionPolicy,
+  DataSourceConfigurationFilterSensitiveLog: () => DataSourceConfigurationFilterSensitiveLog,
+  DataSourceFilterSensitiveLog: () => DataSourceFilterSensitiveLog,
   DataSourceStatus: () => DataSourceStatus,
   DataSourceType: () => DataSourceType,
   DeleteAgentActionGroupCommand: () => DeleteAgentActionGroupCommand,
@@ -57,8 +79,24 @@ __export(src_exports, {
   DeleteAgentCommand: () => DeleteAgentCommand,
   DeleteAgentVersionCommand: () => DeleteAgentVersionCommand,
   DeleteDataSourceCommand: () => DeleteDataSourceCommand,
+  DeleteFlowAliasCommand: () => DeleteFlowAliasCommand,
+  DeleteFlowCommand: () => DeleteFlowCommand,
+  DeleteFlowVersionCommand: () => DeleteFlowVersionCommand,
   DeleteKnowledgeBaseCommand: () => DeleteKnowledgeBaseCommand,
+  DeletePromptCommand: () => DeletePromptCommand,
   DisassociateAgentKnowledgeBaseCommand: () => DisassociateAgentKnowledgeBaseCommand,
+  FlowConditionFilterSensitiveLog: () => FlowConditionFilterSensitiveLog,
+  FlowConnectionConfiguration: () => FlowConnectionConfiguration,
+  FlowConnectionType: () => FlowConnectionType,
+  FlowDefinitionFilterSensitiveLog: () => FlowDefinitionFilterSensitiveLog,
+  FlowNodeConfiguration: () => FlowNodeConfiguration,
+  FlowNodeConfigurationFilterSensitiveLog: () => FlowNodeConfigurationFilterSensitiveLog,
+  FlowNodeFilterSensitiveLog: () => FlowNodeFilterSensitiveLog,
+  FlowNodeIODataType: () => FlowNodeIODataType,
+  FlowNodeInputFilterSensitiveLog: () => FlowNodeInputFilterSensitiveLog,
+  FlowNodeType: () => FlowNodeType,
+  FlowStatus: () => FlowStatus,
+  FlowValidationSeverity: () => FlowValidationSeverity,
   FunctionSchema: () => FunctionSchema,
   GetAgentActionGroupCommand: () => GetAgentActionGroupCommand,
   GetAgentActionGroupResponseFilterSensitiveLog: () => GetAgentActionGroupResponseFilterSensitiveLog,
@@ -69,8 +107,16 @@ __export(src_exports, {
   GetAgentVersionCommand: () => GetAgentVersionCommand,
   GetAgentVersionResponseFilterSensitiveLog: () => GetAgentVersionResponseFilterSensitiveLog,
   GetDataSourceCommand: () => GetDataSourceCommand,
+  GetDataSourceResponseFilterSensitiveLog: () => GetDataSourceResponseFilterSensitiveLog,
+  GetFlowAliasCommand: () => GetFlowAliasCommand,
+  GetFlowCommand: () => GetFlowCommand,
+  GetFlowResponseFilterSensitiveLog: () => GetFlowResponseFilterSensitiveLog,
+  GetFlowVersionCommand: () => GetFlowVersionCommand,
+  GetFlowVersionResponseFilterSensitiveLog: () => GetFlowVersionResponseFilterSensitiveLog,
   GetIngestionJobCommand: () => GetIngestionJobCommand,
   GetKnowledgeBaseCommand: () => GetKnowledgeBaseCommand,
+  GetPromptCommand: () => GetPromptCommand,
+  GetPromptResponseFilterSensitiveLog: () => GetPromptResponseFilterSensitiveLog,
   IngestionJobFilterAttribute: () => IngestionJobFilterAttribute,
   IngestionJobFilterOperator: () => IngestionJobFilterOperator,
   IngestionJobSortByAttribute: () => IngestionJobSortByAttribute,
@@ -86,18 +132,49 @@ __export(src_exports, {
   ListAgentVersionsCommand: () => ListAgentVersionsCommand,
   ListAgentsCommand: () => ListAgentsCommand,
   ListDataSourcesCommand: () => ListDataSourcesCommand,
+  ListFlowAliasesCommand: () => ListFlowAliasesCommand,
+  ListFlowVersionsCommand: () => ListFlowVersionsCommand,
+  ListFlowsCommand: () => ListFlowsCommand,
   ListIngestionJobsCommand: () => ListIngestionJobsCommand,
   ListKnowledgeBasesCommand: () => ListKnowledgeBasesCommand,
+  ListPromptsCommand: () => ListPromptsCommand,
   ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  MemoryType: () => MemoryType,
+  ParsingStrategy: () => ParsingStrategy,
+  PatternObjectFilterConfigurationFilterSensitiveLog: () => PatternObjectFilterConfigurationFilterSensitiveLog,
+  PatternObjectFilterFilterSensitiveLog: () => PatternObjectFilterFilterSensitiveLog,
   PrepareAgentCommand: () => PrepareAgentCommand,
+  PrepareFlowCommand: () => PrepareFlowCommand,
+  PromptConfigurationFilterSensitiveLog: () => PromptConfigurationFilterSensitiveLog,
+  PromptFlowNodeConfigurationFilterSensitiveLog: () => PromptFlowNodeConfigurationFilterSensitiveLog,
+  PromptFlowNodeInlineConfigurationFilterSensitiveLog: () => PromptFlowNodeInlineConfigurationFilterSensitiveLog,
+  PromptFlowNodeSourceConfiguration: () => PromptFlowNodeSourceConfiguration,
+  PromptFlowNodeSourceConfigurationFilterSensitiveLog: () => PromptFlowNodeSourceConfigurationFilterSensitiveLog,
+  PromptInferenceConfiguration: () => PromptInferenceConfiguration,
   PromptOverrideConfigurationFilterSensitiveLog: () => PromptOverrideConfigurationFilterSensitiveLog,
   PromptState: () => PromptState,
+  PromptTemplateConfiguration: () => PromptTemplateConfiguration,
+  PromptTemplateConfigurationFilterSensitiveLog: () => PromptTemplateConfigurationFilterSensitiveLog,
+  PromptTemplateType: () => PromptTemplateType,
   PromptType: () => PromptType,
+  PromptVariantFilterSensitiveLog: () => PromptVariantFilterSensitiveLog,
   ResourceNotFoundException: () => ResourceNotFoundException,
+  RetrievalFlowNodeServiceConfiguration: () => RetrievalFlowNodeServiceConfiguration,
+  S3DataSourceConfigurationFilterSensitiveLog: () => S3DataSourceConfigurationFilterSensitiveLog,
+  SalesforceAuthType: () => SalesforceAuthType,
+  SalesforceCrawlerConfigurationFilterSensitiveLog: () => SalesforceCrawlerConfigurationFilterSensitiveLog,
+  SalesforceDataSourceConfigurationFilterSensitiveLog: () => SalesforceDataSourceConfigurationFilterSensitiveLog,
   ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  SharePointAuthType: () => SharePointAuthType,
+  SharePointCrawlerConfigurationFilterSensitiveLog: () => SharePointCrawlerConfigurationFilterSensitiveLog,
+  SharePointDataSourceConfigurationFilterSensitiveLog: () => SharePointDataSourceConfigurationFilterSensitiveLog,
+  SharePointHostType: () => SharePointHostType,
   SortOrder: () => SortOrder,
   StartIngestionJobCommand: () => StartIngestionJobCommand,
+  StepType: () => StepType,
+  StorageFlowNodeServiceConfiguration: () => StorageFlowNodeServiceConfiguration,
   TagResourceCommand: () => TagResourceCommand,
+  TextPromptTemplateConfigurationFilterSensitiveLog: () => TextPromptTemplateConfigurationFilterSensitiveLog,
   ThrottlingException: () => ThrottlingException,
   Type: () => Type,
   UntagResourceCommand: () => UntagResourceCommand,
@@ -110,8 +187,20 @@ __export(src_exports, {
   UpdateAgentRequestFilterSensitiveLog: () => UpdateAgentRequestFilterSensitiveLog,
   UpdateAgentResponseFilterSensitiveLog: () => UpdateAgentResponseFilterSensitiveLog,
   UpdateDataSourceCommand: () => UpdateDataSourceCommand,
+  UpdateDataSourceRequestFilterSensitiveLog: () => UpdateDataSourceRequestFilterSensitiveLog,
+  UpdateDataSourceResponseFilterSensitiveLog: () => UpdateDataSourceResponseFilterSensitiveLog,
+  UpdateFlowAliasCommand: () => UpdateFlowAliasCommand,
+  UpdateFlowCommand: () => UpdateFlowCommand,
+  UpdateFlowRequestFilterSensitiveLog: () => UpdateFlowRequestFilterSensitiveLog,
+  UpdateFlowResponseFilterSensitiveLog: () => UpdateFlowResponseFilterSensitiveLog,
   UpdateKnowledgeBaseCommand: () => UpdateKnowledgeBaseCommand,
+  UpdatePromptCommand: () => UpdatePromptCommand,
+  UpdatePromptRequestFilterSensitiveLog: () => UpdatePromptRequestFilterSensitiveLog,
+  UpdatePromptResponseFilterSensitiveLog: () => UpdatePromptResponseFilterSensitiveLog,
   ValidationException: () => ValidationException,
+  WebCrawlerConfigurationFilterSensitiveLog: () => WebCrawlerConfigurationFilterSensitiveLog,
+  WebDataSourceConfigurationFilterSensitiveLog: () => WebDataSourceConfigurationFilterSensitiveLog,
+  WebScopeType: () => WebScopeType,
   __Client: () => import_smithy_client.Client,
   paginateListAgentActionGroups: () => paginateListAgentActionGroups,
   paginateListAgentAliases: () => paginateListAgentAliases,
@@ -119,8 +208,12 @@ __export(src_exports, {
   paginateListAgentVersions: () => paginateListAgentVersions,
   paginateListAgents: () => paginateListAgents,
   paginateListDataSources: () => paginateListDataSources,
+  paginateListFlowAliases: () => paginateListFlowAliases,
+  paginateListFlowVersions: () => paginateListFlowVersions,
+  paginateListFlows: () => paginateListFlows,
   paginateListIngestionJobs: () => paginateListIngestionJobs,
-  paginateListKnowledgeBases: () => paginateListKnowledgeBases
+  paginateListKnowledgeBases: () => paginateListKnowledgeBases,
+  paginateListPrompts: () => paginateListPrompts
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -374,6 +467,7 @@ var FunctionSchema;
   }, "visit");
 })(FunctionSchema || (FunctionSchema = {}));
 var ActionGroupSignature = {
+  AMAZON_CODEINTERPRETER: "AMAZON.CodeInterpreter",
   AMAZON_USERINPUT: "AMAZON.UserInput"
 };
 var _InternalServerException = class _InternalServerException extends BedrockAgentServiceException {
@@ -472,6 +566,9 @@ var AgentStatus = {
   UPDATING: "UPDATING",
   VERSIONING: "VERSIONING"
 };
+var MemoryType = {
+  SESSION_SUMMARY: "SESSION_SUMMARY"
+};
 var CreationMode = {
   DEFAULT: "DEFAULT",
   OVERRIDDEN: "OVERRIDDEN"
@@ -501,18 +598,173 @@ var DataDeletionPolicy = {
   DELETE: "DELETE",
   RETAIN: "RETAIN"
 };
+var CrawlFilterConfigurationType = {
+  PATTERN: "PATTERN"
+};
+var ConfluenceAuthType = {
+  BASIC: "BASIC",
+  OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS"
+};
+var ConfluenceHostType = {
+  SAAS: "SAAS"
+};
+var SalesforceAuthType = {
+  OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS"
+};
+var SharePointAuthType = {
+  OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS"
+};
+var SharePointHostType = {
+  ONLINE: "ONLINE"
+};
 var DataSourceType = {
-  S3: "S3"
+  CONFLUENCE: "CONFLUENCE",
+  S3: "S3",
+  SALESFORCE: "SALESFORCE",
+  SHAREPOINT: "SHAREPOINT",
+  WEB: "WEB"
+};
+var WebScopeType = {
+  HOST_ONLY: "HOST_ONLY",
+  SUBDOMAINS: "SUBDOMAINS"
 };
 var ChunkingStrategy = {
   FIXED_SIZE: "FIXED_SIZE",
-  NONE: "NONE"
+  HIERARCHICAL: "HIERARCHICAL",
+  NONE: "NONE",
+  SEMANTIC: "SEMANTIC"
+};
+var StepType = {
+  POST_CHUNKING: "POST_CHUNKING"
+};
+var ParsingStrategy = {
+  BEDROCK_FOUNDATION_MODEL: "BEDROCK_FOUNDATION_MODEL"
 };
 var DataSourceStatus = {
   AVAILABLE: "AVAILABLE",
   DELETE_UNSUCCESSFUL: "DELETE_UNSUCCESSFUL",
   DELETING: "DELETING"
 };
+var FlowConnectionConfiguration;
+((FlowConnectionConfiguration3) => {
+  FlowConnectionConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.data !== void 0)
+      return visitor.data(value.data);
+    if (value.conditional !== void 0)
+      return visitor.conditional(value.conditional);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FlowConnectionConfiguration || (FlowConnectionConfiguration = {}));
+var FlowConnectionType = {
+  CONDITIONAL: "Conditional",
+  DATA: "Data"
+};
+var PromptInferenceConfiguration;
+((PromptInferenceConfiguration2) => {
+  PromptInferenceConfiguration2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PromptInferenceConfiguration || (PromptInferenceConfiguration = {}));
+var PromptTemplateConfiguration;
+((PromptTemplateConfiguration3) => {
+  PromptTemplateConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PromptTemplateConfiguration || (PromptTemplateConfiguration = {}));
+var PromptTemplateType = {
+  TEXT: "TEXT"
+};
+var PromptFlowNodeSourceConfiguration;
+((PromptFlowNodeSourceConfiguration2) => {
+  PromptFlowNodeSourceConfiguration2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.resource !== void 0)
+      return visitor.resource(value.resource);
+    if (value.inline !== void 0)
+      return visitor.inline(value.inline);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PromptFlowNodeSourceConfiguration || (PromptFlowNodeSourceConfiguration = {}));
+var RetrievalFlowNodeServiceConfiguration;
+((RetrievalFlowNodeServiceConfiguration3) => {
+  RetrievalFlowNodeServiceConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.s3 !== void 0)
+      return visitor.s3(value.s3);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RetrievalFlowNodeServiceConfiguration || (RetrievalFlowNodeServiceConfiguration = {}));
+var StorageFlowNodeServiceConfiguration;
+((StorageFlowNodeServiceConfiguration3) => {
+  StorageFlowNodeServiceConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.s3 !== void 0)
+      return visitor.s3(value.s3);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(StorageFlowNodeServiceConfiguration || (StorageFlowNodeServiceConfiguration = {}));
+var FlowNodeConfiguration;
+((FlowNodeConfiguration2) => {
+  FlowNodeConfiguration2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.input !== void 0)
+      return visitor.input(value.input);
+    if (value.output !== void 0)
+      return visitor.output(value.output);
+    if (value.knowledgeBase !== void 0)
+      return visitor.knowledgeBase(value.knowledgeBase);
+    if (value.condition !== void 0)
+      return visitor.condition(value.condition);
+    if (value.lex !== void 0)
+      return visitor.lex(value.lex);
+    if (value.prompt !== void 0)
+      return visitor.prompt(value.prompt);
+    if (value.lambdaFunction !== void 0)
+      return visitor.lambdaFunction(value.lambdaFunction);
+    if (value.storage !== void 0)
+      return visitor.storage(value.storage);
+    if (value.agent !== void 0)
+      return visitor.agent(value.agent);
+    if (value.retrieval !== void 0)
+      return visitor.retrieval(value.retrieval);
+    if (value.iterator !== void 0)
+      return visitor.iterator(value.iterator);
+    if (value.collector !== void 0)
+      return visitor.collector(value.collector);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FlowNodeConfiguration || (FlowNodeConfiguration = {}));
+var FlowNodeIODataType = {
+  ARRAY: "Array",
+  BOOLEAN: "Boolean",
+  NUMBER: "Number",
+  OBJECT: "Object",
+  STRING: "String"
+};
+var 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"
+};
+var FlowStatus = {
+  FAILED: "Failed",
+  NOT_PREPARED: "NotPrepared",
+  PREPARED: "Prepared",
+  PREPARING: "Preparing"
+};
+var FlowValidationSeverity = {
+  ERROR: "Error",
+  WARNING: "Warning"
+};
 var IngestionJobStatus = {
   COMPLETE: "COMPLETE",
   FAILED: "FAILED",
@@ -589,8 +841,15 @@ var UpdateAgentActionGroupResponseFilterSensitiveLog = /* @__PURE__ */ __name((o
   ...obj,
   ...obj.agentActionGroup && { agentActionGroup: AgentActionGroupFilterSensitiveLog(obj.agentActionGroup) }
 }), "UpdateAgentActionGroupResponseFilterSensitiveLog");
+var PromptConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.basePromptTemplate && { basePromptTemplate: import_smithy_client.SENSITIVE_STRING }
+}), "PromptConfigurationFilterSensitiveLog");
 var PromptOverrideConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj
+  ...obj,
+  ...obj.promptConfigurations && {
+    promptConfigurations: obj.promptConfigurations.map((item) => PromptConfigurationFilterSensitiveLog(item))
+  }
 }), "PromptOverrideConfigurationFilterSensitiveLog");
 var AgentFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
@@ -624,6 +883,258 @@ var AgentVersionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj.instruction && { instruction: import_smithy_client.SENSITIVE_STRING },
   ...obj.promptOverrideConfiguration && { promptOverrideConfiguration: import_smithy_client.SENSITIVE_STRING }
 }), "AgentVersionFilterSensitiveLog");
+var PatternObjectFilterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.objectType && { objectType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.inclusionFilters && { inclusionFilters: import_smithy_client.SENSITIVE_STRING },
+  ...obj.exclusionFilters && { exclusionFilters: import_smithy_client.SENSITIVE_STRING }
+}), "PatternObjectFilterFilterSensitiveLog");
+var PatternObjectFilterConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.filters && { filters: import_smithy_client.SENSITIVE_STRING }
+}), "PatternObjectFilterConfigurationFilterSensitiveLog");
+var CrawlFilterConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.patternObjectFilter && {
+    patternObjectFilter: PatternObjectFilterConfigurationFilterSensitiveLog(obj.patternObjectFilter)
+  }
+}), "CrawlFilterConfigurationFilterSensitiveLog");
+var ConfluenceCrawlerConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.filterConfiguration && {
+    filterConfiguration: CrawlFilterConfigurationFilterSensitiveLog(obj.filterConfiguration)
+  }
+}), "ConfluenceCrawlerConfigurationFilterSensitiveLog");
+var ConfluenceDataSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.crawlerConfiguration && {
+    crawlerConfiguration: ConfluenceCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration)
+  }
+}), "ConfluenceDataSourceConfigurationFilterSensitiveLog");
+var S3DataSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.inclusionPrefixes && { inclusionPrefixes: import_smithy_client.SENSITIVE_STRING }
+}), "S3DataSourceConfigurationFilterSensitiveLog");
+var SalesforceCrawlerConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.filterConfiguration && {
+    filterConfiguration: CrawlFilterConfigurationFilterSensitiveLog(obj.filterConfiguration)
+  }
+}), "SalesforceCrawlerConfigurationFilterSensitiveLog");
+var SalesforceDataSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.crawlerConfiguration && {
+    crawlerConfiguration: SalesforceCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration)
+  }
+}), "SalesforceDataSourceConfigurationFilterSensitiveLog");
+var SharePointCrawlerConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.filterConfiguration && {
+    filterConfiguration: CrawlFilterConfigurationFilterSensitiveLog(obj.filterConfiguration)
+  }
+}), "SharePointCrawlerConfigurationFilterSensitiveLog");
+var SharePointDataSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.crawlerConfiguration && {
+    crawlerConfiguration: SharePointCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration)
+  }
+}), "SharePointDataSourceConfigurationFilterSensitiveLog");
+var WebCrawlerConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.inclusionFilters && { inclusionFilters: import_smithy_client.SENSITIVE_STRING },
+  ...obj.exclusionFilters && { exclusionFilters: import_smithy_client.SENSITIVE_STRING }
+}), "WebCrawlerConfigurationFilterSensitiveLog");
+var WebDataSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.crawlerConfiguration && {
+    crawlerConfiguration: WebCrawlerConfigurationFilterSensitiveLog(obj.crawlerConfiguration)
+  }
+}), "WebDataSourceConfigurationFilterSensitiveLog");
+var DataSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((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)
+  }
+}), "DataSourceConfigurationFilterSensitiveLog");
+var CreateDataSourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.dataSourceConfiguration && {
+    dataSourceConfiguration: DataSourceConfigurationFilterSensitiveLog(obj.dataSourceConfiguration)
+  }
+}), "CreateDataSourceRequestFilterSensitiveLog");
+var DataSourceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.dataSourceConfiguration && {
+    dataSourceConfiguration: DataSourceConfigurationFilterSensitiveLog(obj.dataSourceConfiguration)
+  }
+}), "DataSourceFilterSensitiveLog");
+var CreateDataSourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.dataSource && { dataSource: DataSourceFilterSensitiveLog(obj.dataSource) }
+}), "CreateDataSourceResponseFilterSensitiveLog");
+var GetDataSourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.dataSource && { dataSource: DataSourceFilterSensitiveLog(obj.dataSource) }
+}), "GetDataSourceResponseFilterSensitiveLog");
+var UpdateDataSourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.dataSourceConfiguration && {
+    dataSourceConfiguration: DataSourceConfigurationFilterSensitiveLog(obj.dataSourceConfiguration)
+  }
+}), "UpdateDataSourceRequestFilterSensitiveLog");
+var UpdateDataSourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.dataSource && { dataSource: DataSourceFilterSensitiveLog(obj.dataSource) }
+}), "UpdateDataSourceResponseFilterSensitiveLog");
+var FlowConditionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.expression && { expression: import_smithy_client.SENSITIVE_STRING }
+}), "FlowConditionFilterSensitiveLog");
+var ConditionFlowNodeConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.conditions && { conditions: import_smithy_client.SENSITIVE_STRING }
+}), "ConditionFlowNodeConfigurationFilterSensitiveLog");
+var TextPromptTemplateConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.text && { text: import_smithy_client.SENSITIVE_STRING },
+  ...obj.inputVariables && { inputVariables: import_smithy_client.SENSITIVE_STRING }
+}), "TextPromptTemplateConfigurationFilterSensitiveLog");
+var PromptTemplateConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.text !== void 0)
+    return { text: import_smithy_client.SENSITIVE_STRING };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "PromptTemplateConfigurationFilterSensitiveLog");
+var PromptFlowNodeInlineConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.templateConfiguration && {
+    templateConfiguration: PromptTemplateConfigurationFilterSensitiveLog(obj.templateConfiguration)
+  },
+  ...obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }
+}), "PromptFlowNodeInlineConfigurationFilterSensitiveLog");
+var PromptFlowNodeSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.resource !== void 0)
+    return { resource: obj.resource };
+  if (obj.inline !== void 0)
+    return { inline: PromptFlowNodeInlineConfigurationFilterSensitiveLog(obj.inline) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "PromptFlowNodeSourceConfigurationFilterSensitiveLog");
+var PromptFlowNodeConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.sourceConfiguration && {
+    sourceConfiguration: PromptFlowNodeSourceConfigurationFilterSensitiveLog(obj.sourceConfiguration)
+  }
+}), "PromptFlowNodeConfigurationFilterSensitiveLog");
+var FlowNodeConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.input !== void 0)
+    return { input: obj.input };
+  if (obj.output !== void 0)
+    return { output: obj.output };
+  if (obj.knowledgeBase !== void 0)
+    return { knowledgeBase: obj.knowledgeBase };
+  if (obj.condition !== void 0)
+    return { condition: ConditionFlowNodeConfigurationFilterSensitiveLog(obj.condition) };
+  if (obj.lex !== void 0)
+    return { lex: obj.lex };
+  if (obj.prompt !== void 0)
+    return { prompt: PromptFlowNodeConfigurationFilterSensitiveLog(obj.prompt) };
+  if (obj.lambdaFunction !== void 0)
+    return { lambdaFunction: obj.lambdaFunction };
+  if (obj.storage !== void 0)
+    return { storage: obj.storage };
+  if (obj.agent !== void 0)
+    return { agent: obj.agent };
+  if (obj.retrieval !== void 0)
+    return { retrieval: obj.retrieval };
+  if (obj.iterator !== void 0)
+    return { iterator: obj.iterator };
+  if (obj.collector !== void 0)
+    return { collector: obj.collector };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "FlowNodeConfigurationFilterSensitiveLog");
+var FlowNodeInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.expression && { expression: import_smithy_client.SENSITIVE_STRING }
+}), "FlowNodeInputFilterSensitiveLog");
+var FlowNodeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.configuration && { configuration: FlowNodeConfigurationFilterSensitiveLog(obj.configuration) },
+  ...obj.inputs && { inputs: obj.inputs.map((item) => FlowNodeInputFilterSensitiveLog(item)) }
+}), "FlowNodeFilterSensitiveLog");
+var FlowDefinitionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.nodes && { nodes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.connections && { connections: obj.connections.map((item) => item) }
+}), "FlowDefinitionFilterSensitiveLog");
+var CreateFlowRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "CreateFlowRequestFilterSensitiveLog");
+var CreateFlowResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "CreateFlowResponseFilterSensitiveLog");
+var CreateFlowVersionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "CreateFlowVersionResponseFilterSensitiveLog");
+var GetFlowVersionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "GetFlowVersionResponseFilterSensitiveLog");
+var GetFlowResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "GetFlowResponseFilterSensitiveLog");
+var UpdateFlowRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "UpdateFlowRequestFilterSensitiveLog");
+var UpdateFlowResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: FlowDefinitionFilterSensitiveLog(obj.definition) }
+}), "UpdateFlowResponseFilterSensitiveLog");
+var PromptVariantFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.templateConfiguration && {
+    templateConfiguration: PromptTemplateConfigurationFilterSensitiveLog(obj.templateConfiguration)
+  },
+  ...obj.inferenceConfiguration && { inferenceConfiguration: obj.inferenceConfiguration }
+}), "PromptVariantFilterSensitiveLog");
+var CreatePromptRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.variants && { variants: import_smithy_client.SENSITIVE_STRING }
+}), "CreatePromptRequestFilterSensitiveLog");
+var CreatePromptResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.variants && { variants: import_smithy_client.SENSITIVE_STRING }
+}), "CreatePromptResponseFilterSensitiveLog");
+var CreatePromptVersionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.variants && { variants: import_smithy_client.SENSITIVE_STRING }
+}), "CreatePromptVersionResponseFilterSensitiveLog");
+var GetPromptResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.variants && { variants: import_smithy_client.SENSITIVE_STRING }
+}), "GetPromptResponseFilterSensitiveLog");
+var UpdatePromptRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.variants && { variants: import_smithy_client.SENSITIVE_STRING }
+}), "UpdatePromptRequestFilterSensitiveLog");
+var UpdatePromptResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.variants && { variants: import_smithy_client.SENSITIVE_STRING }
+}), "UpdatePromptResponseFilterSensitiveLog");
 var GetAgentVersionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.agentVersion && { agentVersion: AgentVersionFilterSensitiveLog(obj.agentVersion) }
@@ -667,6 +1178,7 @@ var se_CreateAgentCommand = /* @__PURE__ */ __name(async (input, context) => {
       guardrailConfiguration: (_) => (0, import_smithy_client._json)(_),
       idleSessionTTLInSeconds: [],
       instruction: [],
+      memoryConfiguration: (_) => (0, import_smithy_client._json)(_),
       promptOverrideConfiguration: (_) => se_PromptOverrideConfiguration(_, context),
       tags: (_) => (0, import_smithy_client._json)(_)
     })
@@ -740,6 +1252,64 @@ var se_CreateDataSourceCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_CreateDataSourceCommand");
+var se_CreateFlowCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/flows");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      customerEncryptionKeyArn: [],
+      definition: (_) => se_FlowDefinition(_, context),
+      description: [],
+      executionRoleArn: [],
+      name: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateFlowCommand");
+var se_CreateFlowAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/flows/{flowIdentifier}/aliases");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      description: [],
+      name: [],
+      routingConfiguration: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateFlowAliasCommand");
+var se_CreateFlowVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/flows/{flowIdentifier}/versions");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      description: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateFlowVersionCommand");
 var se_CreateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -761,6 +1331,45 @@ var se_CreateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context
   b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_CreateKnowledgeBaseCommand");
+var se_CreatePromptCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prompts");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      customerEncryptionKeyArn: [],
+      defaultVariant: [],
+      description: [],
+      name: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      variants: (_) => se_PromptVariantList(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreatePromptCommand");
+var se_CreatePromptVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prompts/{promptIdentifier}/versions");
+  b.p("promptIdentifier", () => input.promptIdentifier, "{promptIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      description: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreatePromptVersionCommand");
 var se_DeleteAgentCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -820,6 +1429,41 @@ var se_DeleteDataSourceCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_DeleteDataSourceCommand");
+var se_DeleteFlowCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sRIUC]: [() => input.skipResourceInUseCheck !== void 0, () => input[_sRIUC].toString()]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteFlowCommand");
+var se_DeleteFlowAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}/aliases/{aliasIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  b.p("aliasIdentifier", () => input.aliasIdentifier, "{aliasIdentifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteFlowAliasCommand");
+var se_DeleteFlowVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}/versions/{flowVersion}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  b.p("flowVersion", () => input.flowVersion, "{flowVersion}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sRIUC]: [() => input.skipResourceInUseCheck !== void 0, () => input[_sRIUC].toString()]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteFlowVersionCommand");
 var se_DeleteKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -829,6 +1473,18 @@ var se_DeleteKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_DeleteKnowledgeBaseCommand");
+var se_DeletePromptCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prompts/{promptIdentifier}");
+  b.p("promptIdentifier", () => input.promptIdentifier, "{promptIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_pV]: [, input[_pV]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeletePromptCommand");
 var se_DisassociateAgentKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -901,6 +1557,35 @@ var se_GetDataSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("GET").h(headers).b(body);
   return b.build();
 }, "se_GetDataSourceCommand");
+var se_GetFlowCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetFlowCommand");
+var se_GetFlowAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}/aliases/{aliasIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  b.p("aliasIdentifier", () => input.aliasIdentifier, "{aliasIdentifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetFlowAliasCommand");
+var se_GetFlowVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}/versions/{flowVersion}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  b.p("flowVersion", () => input.flowVersion, "{flowVersion}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetFlowVersionCommand");
 var se_GetIngestionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -921,6 +1606,18 @@ var se_GetKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("GET").h(headers).b(body);
   return b.build();
 }, "se_GetKnowledgeBaseCommand");
+var se_GetPromptCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prompts/{promptIdentifier}");
+  b.p("promptIdentifier", () => input.promptIdentifier, "{promptIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_pV]: [, input[_pV]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetPromptCommand");
 var se_ListAgentActionGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1024,6 +1721,44 @@ var se_ListDataSourcesCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_ListDataSourcesCommand");
+var se_ListFlowAliasesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}/aliases");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListFlowAliasesCommand");
+var se_ListFlowsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListFlowsCommand");
+var se_ListFlowVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}/versions");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListFlowVersionsCommand");
 var se_ListIngestionJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1060,6 +1795,19 @@ var se_ListKnowledgeBasesCommand = /* @__PURE__ */ __name(async (input, context)
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_ListKnowledgeBasesCommand");
+var se_ListPromptsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prompts");
+  const query = (0, import_smithy_client.map)({
+    [_pI]: [, input[_pI]],
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListPromptsCommand");
 var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -1078,6 +1826,15 @@ var se_PrepareAgentCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_PrepareAgentCommand");
+var se_PrepareFlowCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/flows/{flowIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PrepareFlowCommand");
 var se_StartIngestionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1145,6 +1902,7 @@ var se_UpdateAgentCommand = /* @__PURE__ */ __name(async (input, context) => {
       guardrailConfiguration: (_) => (0, import_smithy_client._json)(_),
       idleSessionTTLInSeconds: [],
       instruction: [],
+      memoryConfiguration: (_) => (0, import_smithy_client._json)(_),
       promptOverrideConfiguration: (_) => se_PromptOverrideConfiguration(_, context)
     })
   );
@@ -1235,26 +1993,85 @@ var se_UpdateDataSourceCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_UpdateDataSourceCommand");
-var se_UpdateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+var se_UpdateFlowCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
     "content-type": "application/json"
   };
-  b.bp("/knowledgebases/{knowledgeBaseId}");
-  b.p("knowledgeBaseId", () => input.knowledgeBaseId, "{knowledgeBaseId}", false);
+  b.bp("/flows/{flowIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
+      customerEncryptionKeyArn: [],
+      definition: (_) => se_FlowDefinition(_, context),
       description: [],
-      knowledgeBaseConfiguration: (_) => (0, import_smithy_client._json)(_),
-      name: [],
-      roleArn: [],
+      executionRoleArn: [],
+      name: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateFlowCommand");
+var se_UpdateFlowAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/flows/{flowIdentifier}/aliases/{aliasIdentifier}");
+  b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+  b.p("aliasIdentifier", () => input.aliasIdentifier, "{aliasIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      name: [],
+      routingConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateFlowAliasCommand");
+var se_UpdateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/knowledgebases/{knowledgeBaseId}");
+  b.p("knowledgeBaseId", () => input.knowledgeBaseId, "{knowledgeBaseId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      knowledgeBaseConfiguration: (_) => (0, import_smithy_client._json)(_),
+      name: [],
+      roleArn: [],
       storageConfiguration: (_) => (0, import_smithy_client._json)(_)
     })
   );
   b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_UpdateKnowledgeBaseCommand");
+var se_UpdatePromptCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prompts/{promptIdentifier}");
+  b.p("promptIdentifier", () => input.promptIdentifier, "{promptIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      customerEncryptionKeyArn: [],
+      defaultVariant: [],
+      description: [],
+      name: [],
+      variants: (_) => se_PromptVariantList(_, context)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdatePromptCommand");
 var de_AssociateAgentKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1325,6 +2142,74 @@ var de_CreateDataSourceCommand = /* @__PURE__ */ __name(async (output, context)
   Object.assign(contents, doc);
   return contents;
 }, "de_CreateDataSourceCommand");
+var de_CreateFlowCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    definition: (_) => de_FlowDefinition(_, context),
+    description: import_smithy_client.expectString,
+    executionRoleArn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateFlowCommand");
+var de_CreateFlowAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    description: import_smithy_client.expectString,
+    flowId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    routingConfiguration: import_smithy_client._json,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateFlowAliasCommand");
+var de_CreateFlowVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    definition: (_) => de_FlowDefinition(_, context),
+    description: import_smithy_client.expectString,
+    executionRoleArn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateFlowVersionCommand");
 var de_CreateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 202 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1339,6 +2224,52 @@ var de_CreateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, contex
   Object.assign(contents, doc);
   return contents;
 }, "de_CreateKnowledgeBaseCommand");
+var de_CreatePromptCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    defaultVariant: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    variants: (_) => de_PromptVariantList(_, context),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreatePromptCommand");
+var de_CreatePromptVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    defaultVariant: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    variants: (_) => de_PromptVariantList(_, context),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreatePromptVersionCommand");
 var de_DeleteAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 202 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1412,6 +2343,50 @@ var de_DeleteDataSourceCommand = /* @__PURE__ */ __name(async (output, context)
   Object.assign(contents, doc);
   return contents;
 }, "de_DeleteDataSourceCommand");
+var de_DeleteFlowCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    id: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteFlowCommand");
+var de_DeleteFlowAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    flowId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteFlowAliasCommand");
+var de_DeleteFlowVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    id: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteFlowVersionCommand");
 var de_DeleteKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 202 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1427,6 +2402,21 @@ var de_DeleteKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, contex
   Object.assign(contents, doc);
   return contents;
 }, "de_DeleteKnowledgeBaseCommand");
+var de_DeletePromptCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    id: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeletePromptCommand");
 var de_DisassociateAgentKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 204 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1521,6 +2511,75 @@ var de_GetDataSourceCommand = /* @__PURE__ */ __name(async (output, context) =>
   Object.assign(contents, doc);
   return contents;
 }, "de_GetDataSourceCommand");
+var de_GetFlowCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    definition: (_) => de_FlowDefinition(_, context),
+    description: import_smithy_client.expectString,
+    executionRoleArn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    validations: import_smithy_client._json,
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetFlowCommand");
+var de_GetFlowAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    description: import_smithy_client.expectString,
+    flowId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    routingConfiguration: import_smithy_client._json,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetFlowAliasCommand");
+var de_GetFlowVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    definition: (_) => de_FlowDefinition(_, context),
+    description: import_smithy_client.expectString,
+    executionRoleArn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetFlowVersionCommand");
 var de_GetIngestionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1549,6 +2608,29 @@ var de_GetKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, context)
   Object.assign(contents, doc);
   return contents;
 }, "de_GetKnowledgeBaseCommand");
+var de_GetPromptCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    defaultVariant: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    variants: (_) => de_PromptVariantList(_, context),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetPromptCommand");
 var de_ListAgentActionGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1639,6 +2721,51 @@ var de_ListDataSourcesCommand = /* @__PURE__ */ __name(async (output, context) =
   Object.assign(contents, doc);
   return contents;
 }, "de_ListDataSourcesCommand");
+var de_ListFlowAliasesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    flowAliasSummaries: (_) => de_FlowAliasSummaries(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFlowAliasesCommand");
+var de_ListFlowsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    flowSummaries: (_) => de_FlowSummaries(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFlowsCommand");
+var de_ListFlowVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    flowVersionSummaries: (_) => de_FlowVersionSummaries(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFlowVersionsCommand");
 var de_ListIngestionJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1669,6 +2796,21 @@ var de_ListKnowledgeBasesCommand = /* @__PURE__ */ __name(async (output, context
   Object.assign(contents, doc);
   return contents;
 }, "de_ListKnowledgeBasesCommand");
+var de_ListPromptsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    promptSummaries: (_) => de_PromptSummaries(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListPromptsCommand");
 var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1700,6 +2842,21 @@ var de_PrepareAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
   Object.assign(contents, doc);
   return contents;
 }, "de_PrepareAgentCommand");
+var de_PrepareFlowCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    id: import_smithy_client.expectString,
+    status: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PrepareFlowCommand");
 var de_StartIngestionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 202 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1804,6 +2961,51 @@ var de_UpdateDataSourceCommand = /* @__PURE__ */ __name(async (output, context)
   Object.assign(contents, doc);
   return contents;
 }, "de_UpdateDataSourceCommand");
+var de_UpdateFlowCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    definition: (_) => de_FlowDefinition(_, context),
+    description: import_smithy_client.expectString,
+    executionRoleArn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateFlowCommand");
+var de_UpdateFlowAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    description: import_smithy_client.expectString,
+    flowId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    routingConfiguration: import_smithy_client._json,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateFlowAliasCommand");
 var de_UpdateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 202 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1818,6 +3020,29 @@ var de_UpdateKnowledgeBaseCommand = /* @__PURE__ */ __name(async (output, contex
   Object.assign(contents, doc);
   return contents;
 }, "de_UpdateKnowledgeBaseCommand");
+var de_UpdatePromptCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    customerEncryptionKeyArn: import_smithy_client.expectString,
+    defaultVariant: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    variants: (_) => de_PromptVariantList(_, context),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdatePromptCommand");
 var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
   const parsedOutput = {
     ...output,
@@ -1948,6 +3173,43 @@ var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, cont
   });
   return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
 }, "de_ValidationExceptionRes");
+var se_FlowDefinition = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    connections: import_smithy_client._json,
+    nodes: (_) => se_FlowNodes(_, context)
+  });
+}, "se_FlowDefinition");
+var se_FlowNode = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    configuration: (_) => se_FlowNodeConfiguration(_, context),
+    inputs: import_smithy_client._json,
+    name: [],
+    outputs: import_smithy_client._json,
+    type: []
+  });
+}, "se_FlowNode");
+var se_FlowNodeConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return FlowNodeConfiguration.visit(input, {
+    agent: (value) => ({ agent: (0, import_smithy_client._json)(value) }),
+    collector: (value) => ({ collector: (0, import_smithy_client._json)(value) }),
+    condition: (value) => ({ condition: (0, import_smithy_client._json)(value) }),
+    input: (value) => ({ input: (0, import_smithy_client._json)(value) }),
+    iterator: (value) => ({ iterator: (0, import_smithy_client._json)(value) }),
+    knowledgeBase: (value) => ({ knowledgeBase: (0, import_smithy_client._json)(value) }),
+    lambdaFunction: (value) => ({ lambdaFunction: (0, import_smithy_client._json)(value) }),
+    lex: (value) => ({ lex: (0, import_smithy_client._json)(value) }),
+    output: (value) => ({ output: (0, import_smithy_client._json)(value) }),
+    prompt: (value) => ({ prompt: se_PromptFlowNodeConfiguration(value, context) }),
+    retrieval: (value) => ({ retrieval: (0, import_smithy_client._json)(value) }),
+    storage: (value) => ({ storage: (0, import_smithy_client._json)(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_FlowNodeConfiguration");
+var se_FlowNodes = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_FlowNode(entry, context);
+  });
+}, "se_FlowNodes");
 var se_InferenceConfiguration = /* @__PURE__ */ __name((input, context) => {
   return (0, import_smithy_client.take)(input, {
     maximumLength: [],
@@ -1972,12 +3234,61 @@ var se_PromptConfigurations = /* @__PURE__ */ __name((input, context) => {
     return se_PromptConfiguration(entry, context);
   });
 }, "se_PromptConfigurations");
+var se_PromptFlowNodeConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    sourceConfiguration: (_) => se_PromptFlowNodeSourceConfiguration(_, context)
+  });
+}, "se_PromptFlowNodeConfiguration");
+var se_PromptFlowNodeInlineConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    inferenceConfiguration: (_) => se_PromptInferenceConfiguration(_, context),
+    modelId: [],
+    templateConfiguration: import_smithy_client._json,
+    templateType: []
+  });
+}, "se_PromptFlowNodeInlineConfiguration");
+var se_PromptFlowNodeSourceConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return PromptFlowNodeSourceConfiguration.visit(input, {
+    inline: (value) => ({ inline: se_PromptFlowNodeInlineConfiguration(value, context) }),
+    resource: (value) => ({ resource: (0, import_smithy_client._json)(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_PromptFlowNodeSourceConfiguration");
+var se_PromptInferenceConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return PromptInferenceConfiguration.visit(input, {
+    text: (value) => ({ text: se_PromptModelInferenceConfiguration(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_PromptInferenceConfiguration");
+var se_PromptModelInferenceConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    maxTokens: [],
+    stopSequences: import_smithy_client._json,
+    temperature: import_smithy_client.serializeFloat,
+    topK: [],
+    topP: import_smithy_client.serializeFloat
+  });
+}, "se_PromptModelInferenceConfiguration");
 var se_PromptOverrideConfiguration = /* @__PURE__ */ __name((input, context) => {
   return (0, import_smithy_client.take)(input, {
     overrideLambda: [],
     promptConfigurations: (_) => se_PromptConfigurations(_, context)
   });
 }, "se_PromptOverrideConfiguration");
+var se_PromptVariant = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    inferenceConfiguration: (_) => se_PromptInferenceConfiguration(_, context),
+    modelId: [],
+    name: [],
+    templateConfiguration: import_smithy_client._json,
+    templateType: []
+  });
+}, "se_PromptVariant");
+var se_PromptVariantList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_PromptVariant(entry, context);
+  });
+}, "se_PromptVariantList");
 var de_ActionGroupSummaries = /* @__PURE__ */ __name((output, context) => {
   const retVal = (output || []).filter((e) => e != null).map((entry) => {
     return de_ActionGroupSummary(entry, context);
@@ -2010,6 +3321,7 @@ var de_Agent = /* @__PURE__ */ __name((output, context) => {
     guardrailConfiguration: import_smithy_client._json,
     idleSessionTTLInSeconds: import_smithy_client.expectInt32,
     instruction: import_smithy_client.expectString,
+    memoryConfiguration: import_smithy_client._json,
     preparedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
     promptOverrideConfiguration: (_) => de_PromptOverrideConfiguration(_, context),
     recommendedActions: import_smithy_client._json,
@@ -2136,6 +3448,7 @@ var de_AgentVersion = /* @__PURE__ */ __name((output, context) => {
     guardrailConfiguration: import_smithy_client._json,
     idleSessionTTLInSeconds: import_smithy_client.expectInt32,
     instruction: import_smithy_client.expectString,
+    memoryConfiguration: import_smithy_client._json,
     promptOverrideConfiguration: (_) => de_PromptOverrideConfiguration(_, context),
     recommendedActions: import_smithy_client._json,
     updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
@@ -2191,6 +3504,141 @@ var de_DataSourceSummary = /* @__PURE__ */ __name((output, context) => {
     updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
   });
 }, "de_DataSourceSummary");
+var de_FlowAliasSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowAliasSummary(entry, context);
+  });
+  return retVal;
+}, "de_FlowAliasSummaries");
+var de_FlowAliasSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    description: import_smithy_client.expectString,
+    flowId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    routingConfiguration: import_smithy_client._json,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_FlowAliasSummary");
+var de_FlowDefinition = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    connections: import_smithy_client._json,
+    nodes: (_) => de_FlowNodes(_, context)
+  });
+}, "de_FlowDefinition");
+var de_FlowNode = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    configuration: (_) => de_FlowNodeConfiguration((0, import_core2.awsExpectUnion)(_), context),
+    inputs: import_smithy_client._json,
+    name: import_smithy_client.expectString,
+    outputs: import_smithy_client._json,
+    type: import_smithy_client.expectString
+  });
+}, "de_FlowNode");
+var de_FlowNodeConfiguration = /* @__PURE__ */ __name((output, context) => {
+  if (output.agent != null) {
+    return {
+      agent: (0, import_smithy_client._json)(output.agent)
+    };
+  }
+  if (output.collector != null) {
+    return {
+      collector: (0, import_smithy_client._json)(output.collector)
+    };
+  }
+  if (output.condition != null) {
+    return {
+      condition: (0, import_smithy_client._json)(output.condition)
+    };
+  }
+  if (output.input != null) {
+    return {
+      input: (0, import_smithy_client._json)(output.input)
+    };
+  }
+  if (output.iterator != null) {
+    return {
+      iterator: (0, import_smithy_client._json)(output.iterator)
+    };
+  }
+  if (output.knowledgeBase != null) {
+    return {
+      knowledgeBase: (0, import_smithy_client._json)(output.knowledgeBase)
+    };
+  }
+  if (output.lambdaFunction != null) {
+    return {
+      lambdaFunction: (0, import_smithy_client._json)(output.lambdaFunction)
+    };
+  }
+  if (output.lex != null) {
+    return {
+      lex: (0, import_smithy_client._json)(output.lex)
+    };
+  }
+  if (output.output != null) {
+    return {
+      output: (0, import_smithy_client._json)(output.output)
+    };
+  }
+  if (output.prompt != null) {
+    return {
+      prompt: de_PromptFlowNodeConfiguration(output.prompt, context)
+    };
+  }
+  if (output.retrieval != null) {
+    return {
+      retrieval: (0, import_smithy_client._json)(output.retrieval)
+    };
+  }
+  if (output.storage != null) {
+    return {
+      storage: (0, import_smithy_client._json)(output.storage)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_FlowNodeConfiguration");
+var de_FlowNodes = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowNode(entry, context);
+  });
+  return retVal;
+}, "de_FlowNodes");
+var de_FlowSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowSummary(entry, context);
+  });
+  return retVal;
+}, "de_FlowSummaries");
+var de_FlowSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    version: import_smithy_client.expectString
+  });
+}, "de_FlowSummary");
+var de_FlowVersionSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowVersionSummary(entry, context);
+  });
+  return retVal;
+}, "de_FlowVersionSummaries");
+var de_FlowVersionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    id: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+}, "de_FlowVersionSummary");
 var de_InferenceConfiguration = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     maximumLength: import_smithy_client.expectInt32,
@@ -2277,18 +3725,97 @@ var de_PromptConfigurations = /* @__PURE__ */ __name((output, context) => {
   });
   return retVal;
 }, "de_PromptConfigurations");
+var de_PromptFlowNodeConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    sourceConfiguration: (_) => de_PromptFlowNodeSourceConfiguration((0, import_core2.awsExpectUnion)(_), context)
+  });
+}, "de_PromptFlowNodeConfiguration");
+var de_PromptFlowNodeInlineConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    inferenceConfiguration: (_) => de_PromptInferenceConfiguration((0, import_core2.awsExpectUnion)(_), context),
+    modelId: import_smithy_client.expectString,
+    templateConfiguration: (_) => (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(_)),
+    templateType: import_smithy_client.expectString
+  });
+}, "de_PromptFlowNodeInlineConfiguration");
+var de_PromptFlowNodeSourceConfiguration = /* @__PURE__ */ __name((output, context) => {
+  if (output.inline != null) {
+    return {
+      inline: de_PromptFlowNodeInlineConfiguration(output.inline, context)
+    };
+  }
+  if (output.resource != null) {
+    return {
+      resource: (0, import_smithy_client._json)(output.resource)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_PromptFlowNodeSourceConfiguration");
+var de_PromptInferenceConfiguration = /* @__PURE__ */ __name((output, context) => {
+  if (output.text != null) {
+    return {
+      text: de_PromptModelInferenceConfiguration(output.text, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_PromptInferenceConfiguration");
+var de_PromptModelInferenceConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    maxTokens: import_smithy_client.expectInt32,
+    stopSequences: import_smithy_client._json,
+    temperature: import_smithy_client.limitedParseFloat32,
+    topK: import_smithy_client.expectInt32,
+    topP: import_smithy_client.limitedParseFloat32
+  });
+}, "de_PromptModelInferenceConfiguration");
 var de_PromptOverrideConfiguration = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     overrideLambda: import_smithy_client.expectString,
     promptConfigurations: (_) => de_PromptConfigurations(_, context)
   });
 }, "de_PromptOverrideConfiguration");
+var de_PromptSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_PromptSummary(entry, context);
+  });
+  return retVal;
+}, "de_PromptSummaries");
+var de_PromptSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    version: import_smithy_client.expectString
+  });
+}, "de_PromptSummary");
+var de_PromptVariant = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    inferenceConfiguration: (_) => de_PromptInferenceConfiguration((0, import_core2.awsExpectUnion)(_), context),
+    modelId: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    templateConfiguration: (_) => (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(_)),
+    templateType: import_smithy_client.expectString
+  });
+}, "de_PromptVariant");
+var de_PromptVariantList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_PromptVariant(entry, context);
+  });
+  return retVal;
+}, "de_PromptVariantList");
 var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
   httpStatusCode: output.statusCode,
   requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
   extendedRequestId: output.headers["x-amz-id-2"],
   cfId: output.headers["x-amz-cf-id"]
 }), "deserializeMetadata");
+var _mR = "maxResults";
+var _nT = "nextToken";
+var _pI = "promptIdentifier";
+var _pV = "promptVersion";
 var _sRIUC = "skipResourceInUseCheck";
 var _tK = "tagKeys";
 
@@ -2364,11 +3891,59 @@ var _CreateDataSourceCommand = class _CreateDataSourceCommand extends import_smi
     (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
     (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
   ];
-}).s("AmazonBedrockAgentBuildTimeLambda", "CreateDataSource", {}).n("BedrockAgentClient", "CreateDataSourceCommand").f(void 0, void 0).ser(se_CreateDataSourceCommand).de(de_CreateDataSourceCommand).build() {
+}).s("AmazonBedrockAgentBuildTimeLambda", "CreateDataSource", {}).n("BedrockAgentClient", "CreateDataSourceCommand").f(CreateDataSourceRequestFilterSensitiveLog, CreateDataSourceResponseFilterSensitiveLog).ser(se_CreateDataSourceCommand).de(de_CreateDataSourceCommand).build() {
 };
 __name(_CreateDataSourceCommand, "CreateDataSourceCommand");
 var CreateDataSourceCommand = _CreateDataSourceCommand;
 
+// src/commands/CreateFlowAliasCommand.ts
+
+
+
+var _CreateFlowAliasCommand = class _CreateFlowAliasCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "CreateFlowAlias", {}).n("BedrockAgentClient", "CreateFlowAliasCommand").f(void 0, void 0).ser(se_CreateFlowAliasCommand).de(de_CreateFlowAliasCommand).build() {
+};
+__name(_CreateFlowAliasCommand, "CreateFlowAliasCommand");
+var CreateFlowAliasCommand = _CreateFlowAliasCommand;
+
+// src/commands/CreateFlowCommand.ts
+
+
+
+var _CreateFlowCommand = class _CreateFlowCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "CreateFlow", {}).n("BedrockAgentClient", "CreateFlowCommand").f(CreateFlowRequestFilterSensitiveLog, CreateFlowResponseFilterSensitiveLog).ser(se_CreateFlowCommand).de(de_CreateFlowCommand).build() {
+};
+__name(_CreateFlowCommand, "CreateFlowCommand");
+var CreateFlowCommand = _CreateFlowCommand;
+
+// src/commands/CreateFlowVersionCommand.ts
+
+
+
+var _CreateFlowVersionCommand = class _CreateFlowVersionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "CreateFlowVersion", {}).n("BedrockAgentClient", "CreateFlowVersionCommand").f(void 0, CreateFlowVersionResponseFilterSensitiveLog).ser(se_CreateFlowVersionCommand).de(de_CreateFlowVersionCommand).build() {
+};
+__name(_CreateFlowVersionCommand, "CreateFlowVersionCommand");
+var CreateFlowVersionCommand = _CreateFlowVersionCommand;
+
 // src/commands/CreateKnowledgeBaseCommand.ts
 
 
@@ -2385,6 +3960,38 @@ var _CreateKnowledgeBaseCommand = class _CreateKnowledgeBaseCommand extends impo
 __name(_CreateKnowledgeBaseCommand, "CreateKnowledgeBaseCommand");
 var CreateKnowledgeBaseCommand = _CreateKnowledgeBaseCommand;
 
+// src/commands/CreatePromptCommand.ts
+
+
+
+var _CreatePromptCommand = class _CreatePromptCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "CreatePrompt", {}).n("BedrockAgentClient", "CreatePromptCommand").f(CreatePromptRequestFilterSensitiveLog, CreatePromptResponseFilterSensitiveLog).ser(se_CreatePromptCommand).de(de_CreatePromptCommand).build() {
+};
+__name(_CreatePromptCommand, "CreatePromptCommand");
+var CreatePromptCommand = _CreatePromptCommand;
+
+// src/commands/CreatePromptVersionCommand.ts
+
+
+
+var _CreatePromptVersionCommand = class _CreatePromptVersionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "CreatePromptVersion", {}).n("BedrockAgentClient", "CreatePromptVersionCommand").f(void 0, CreatePromptVersionResponseFilterSensitiveLog).ser(se_CreatePromptVersionCommand).de(de_CreatePromptVersionCommand).build() {
+};
+__name(_CreatePromptVersionCommand, "CreatePromptVersionCommand");
+var CreatePromptVersionCommand = _CreatePromptVersionCommand;
+
 // src/commands/DeleteAgentActionGroupCommand.ts
 
 
@@ -2465,6 +4072,54 @@ var _DeleteDataSourceCommand = class _DeleteDataSourceCommand extends import_smi
 __name(_DeleteDataSourceCommand, "DeleteDataSourceCommand");
 var DeleteDataSourceCommand = _DeleteDataSourceCommand;
 
+// src/commands/DeleteFlowAliasCommand.ts
+
+
+
+var _DeleteFlowAliasCommand = class _DeleteFlowAliasCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "DeleteFlowAlias", {}).n("BedrockAgentClient", "DeleteFlowAliasCommand").f(void 0, void 0).ser(se_DeleteFlowAliasCommand).de(de_DeleteFlowAliasCommand).build() {
+};
+__name(_DeleteFlowAliasCommand, "DeleteFlowAliasCommand");
+var DeleteFlowAliasCommand = _DeleteFlowAliasCommand;
+
+// src/commands/DeleteFlowCommand.ts
+
+
+
+var _DeleteFlowCommand = class _DeleteFlowCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "DeleteFlow", {}).n("BedrockAgentClient", "DeleteFlowCommand").f(void 0, void 0).ser(se_DeleteFlowCommand).de(de_DeleteFlowCommand).build() {
+};
+__name(_DeleteFlowCommand, "DeleteFlowCommand");
+var DeleteFlowCommand = _DeleteFlowCommand;
+
+// src/commands/DeleteFlowVersionCommand.ts
+
+
+
+var _DeleteFlowVersionCommand = class _DeleteFlowVersionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "DeleteFlowVersion", {}).n("BedrockAgentClient", "DeleteFlowVersionCommand").f(void 0, void 0).ser(se_DeleteFlowVersionCommand).de(de_DeleteFlowVersionCommand).build() {
+};
+__name(_DeleteFlowVersionCommand, "DeleteFlowVersionCommand");
+var DeleteFlowVersionCommand = _DeleteFlowVersionCommand;
+
 // src/commands/DeleteKnowledgeBaseCommand.ts
 
 
@@ -2481,6 +4136,22 @@ var _DeleteKnowledgeBaseCommand = class _DeleteKnowledgeBaseCommand extends impo
 __name(_DeleteKnowledgeBaseCommand, "DeleteKnowledgeBaseCommand");
 var DeleteKnowledgeBaseCommand = _DeleteKnowledgeBaseCommand;
 
+// src/commands/DeletePromptCommand.ts
+
+
+
+var _DeletePromptCommand = class _DeletePromptCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "DeletePrompt", {}).n("BedrockAgentClient", "DeletePromptCommand").f(void 0, void 0).ser(se_DeletePromptCommand).de(de_DeletePromptCommand).build() {
+};
+__name(_DeletePromptCommand, "DeletePromptCommand");
+var DeletePromptCommand = _DeletePromptCommand;
+
 // src/commands/DisassociateAgentKnowledgeBaseCommand.ts
 
 
@@ -2588,11 +4259,59 @@ var _GetDataSourceCommand = class _GetDataSourceCommand extends import_smithy_cl
     (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
     (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
   ];
-}).s("AmazonBedrockAgentBuildTimeLambda", "GetDataSource", {}).n("BedrockAgentClient", "GetDataSourceCommand").f(void 0, void 0).ser(se_GetDataSourceCommand).de(de_GetDataSourceCommand).build() {
+}).s("AmazonBedrockAgentBuildTimeLambda", "GetDataSource", {}).n("BedrockAgentClient", "GetDataSourceCommand").f(void 0, GetDataSourceResponseFilterSensitiveLog).ser(se_GetDataSourceCommand).de(de_GetDataSourceCommand).build() {
 };
 __name(_GetDataSourceCommand, "GetDataSourceCommand");
 var GetDataSourceCommand = _GetDataSourceCommand;
 
+// src/commands/GetFlowAliasCommand.ts
+
+
+
+var _GetFlowAliasCommand = class _GetFlowAliasCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "GetFlowAlias", {}).n("BedrockAgentClient", "GetFlowAliasCommand").f(void 0, void 0).ser(se_GetFlowAliasCommand).de(de_GetFlowAliasCommand).build() {
+};
+__name(_GetFlowAliasCommand, "GetFlowAliasCommand");
+var GetFlowAliasCommand = _GetFlowAliasCommand;
+
+// src/commands/GetFlowCommand.ts
+
+
+
+var _GetFlowCommand = class _GetFlowCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "GetFlow", {}).n("BedrockAgentClient", "GetFlowCommand").f(void 0, GetFlowResponseFilterSensitiveLog).ser(se_GetFlowCommand).de(de_GetFlowCommand).build() {
+};
+__name(_GetFlowCommand, "GetFlowCommand");
+var GetFlowCommand = _GetFlowCommand;
+
+// src/commands/GetFlowVersionCommand.ts
+
+
+
+var _GetFlowVersionCommand = class _GetFlowVersionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "GetFlowVersion", {}).n("BedrockAgentClient", "GetFlowVersionCommand").f(void 0, GetFlowVersionResponseFilterSensitiveLog).ser(se_GetFlowVersionCommand).de(de_GetFlowVersionCommand).build() {
+};
+__name(_GetFlowVersionCommand, "GetFlowVersionCommand");
+var GetFlowVersionCommand = _GetFlowVersionCommand;
+
 // src/commands/GetIngestionJobCommand.ts
 
 
@@ -2625,6 +4344,22 @@ var _GetKnowledgeBaseCommand = class _GetKnowledgeBaseCommand extends import_smi
 __name(_GetKnowledgeBaseCommand, "GetKnowledgeBaseCommand");
 var GetKnowledgeBaseCommand = _GetKnowledgeBaseCommand;
 
+// src/commands/GetPromptCommand.ts
+
+
+
+var _GetPromptCommand = class _GetPromptCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "GetPrompt", {}).n("BedrockAgentClient", "GetPromptCommand").f(void 0, GetPromptResponseFilterSensitiveLog).ser(se_GetPromptCommand).de(de_GetPromptCommand).build() {
+};
+__name(_GetPromptCommand, "GetPromptCommand");
+var GetPromptCommand = _GetPromptCommand;
+
 // src/commands/ListAgentActionGroupsCommand.ts
 
 
@@ -2721,6 +4456,54 @@ var _ListDataSourcesCommand = class _ListDataSourcesCommand extends import_smith
 __name(_ListDataSourcesCommand, "ListDataSourcesCommand");
 var ListDataSourcesCommand = _ListDataSourcesCommand;
 
+// src/commands/ListFlowAliasesCommand.ts
+
+
+
+var _ListFlowAliasesCommand = class _ListFlowAliasesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "ListFlowAliases", {}).n("BedrockAgentClient", "ListFlowAliasesCommand").f(void 0, void 0).ser(se_ListFlowAliasesCommand).de(de_ListFlowAliasesCommand).build() {
+};
+__name(_ListFlowAliasesCommand, "ListFlowAliasesCommand");
+var ListFlowAliasesCommand = _ListFlowAliasesCommand;
+
+// src/commands/ListFlowsCommand.ts
+
+
+
+var _ListFlowsCommand = class _ListFlowsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "ListFlows", {}).n("BedrockAgentClient", "ListFlowsCommand").f(void 0, void 0).ser(se_ListFlowsCommand).de(de_ListFlowsCommand).build() {
+};
+__name(_ListFlowsCommand, "ListFlowsCommand");
+var ListFlowsCommand = _ListFlowsCommand;
+
+// src/commands/ListFlowVersionsCommand.ts
+
+
+
+var _ListFlowVersionsCommand = class _ListFlowVersionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "ListFlowVersions", {}).n("BedrockAgentClient", "ListFlowVersionsCommand").f(void 0, void 0).ser(se_ListFlowVersionsCommand).de(de_ListFlowVersionsCommand).build() {
+};
+__name(_ListFlowVersionsCommand, "ListFlowVersionsCommand");
+var ListFlowVersionsCommand = _ListFlowVersionsCommand;
+
 // src/commands/ListIngestionJobsCommand.ts
 
 
@@ -2753,6 +4536,22 @@ var _ListKnowledgeBasesCommand = class _ListKnowledgeBasesCommand extends import
 __name(_ListKnowledgeBasesCommand, "ListKnowledgeBasesCommand");
 var ListKnowledgeBasesCommand = _ListKnowledgeBasesCommand;
 
+// src/commands/ListPromptsCommand.ts
+
+
+
+var _ListPromptsCommand = class _ListPromptsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "ListPrompts", {}).n("BedrockAgentClient", "ListPromptsCommand").f(void 0, void 0).ser(se_ListPromptsCommand).de(de_ListPromptsCommand).build() {
+};
+__name(_ListPromptsCommand, "ListPromptsCommand");
+var ListPromptsCommand = _ListPromptsCommand;
+
 // src/commands/ListTagsForResourceCommand.ts
 
 
@@ -2785,6 +4584,22 @@ var _PrepareAgentCommand = class _PrepareAgentCommand extends import_smithy_clie
 __name(_PrepareAgentCommand, "PrepareAgentCommand");
 var PrepareAgentCommand = _PrepareAgentCommand;
 
+// src/commands/PrepareFlowCommand.ts
+
+
+
+var _PrepareFlowCommand = class _PrepareFlowCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "PrepareFlow", {}).n("BedrockAgentClient", "PrepareFlowCommand").f(void 0, void 0).ser(se_PrepareFlowCommand).de(de_PrepareFlowCommand).build() {
+};
+__name(_PrepareFlowCommand, "PrepareFlowCommand");
+var PrepareFlowCommand = _PrepareFlowCommand;
+
 // src/commands/StartIngestionJobCommand.ts
 
 
@@ -2908,11 +4723,43 @@ var _UpdateDataSourceCommand = class _UpdateDataSourceCommand extends import_smi
     (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
     (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
   ];
-}).s("AmazonBedrockAgentBuildTimeLambda", "UpdateDataSource", {}).n("BedrockAgentClient", "UpdateDataSourceCommand").f(void 0, void 0).ser(se_UpdateDataSourceCommand).de(de_UpdateDataSourceCommand).build() {
+}).s("AmazonBedrockAgentBuildTimeLambda", "UpdateDataSource", {}).n("BedrockAgentClient", "UpdateDataSourceCommand").f(UpdateDataSourceRequestFilterSensitiveLog, UpdateDataSourceResponseFilterSensitiveLog).ser(se_UpdateDataSourceCommand).de(de_UpdateDataSourceCommand).build() {
 };
 __name(_UpdateDataSourceCommand, "UpdateDataSourceCommand");
 var UpdateDataSourceCommand = _UpdateDataSourceCommand;
 
+// src/commands/UpdateFlowAliasCommand.ts
+
+
+
+var _UpdateFlowAliasCommand = class _UpdateFlowAliasCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "UpdateFlowAlias", {}).n("BedrockAgentClient", "UpdateFlowAliasCommand").f(void 0, void 0).ser(se_UpdateFlowAliasCommand).de(de_UpdateFlowAliasCommand).build() {
+};
+__name(_UpdateFlowAliasCommand, "UpdateFlowAliasCommand");
+var UpdateFlowAliasCommand = _UpdateFlowAliasCommand;
+
+// src/commands/UpdateFlowCommand.ts
+
+
+
+var _UpdateFlowCommand = class _UpdateFlowCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "UpdateFlow", {}).n("BedrockAgentClient", "UpdateFlowCommand").f(UpdateFlowRequestFilterSensitiveLog, UpdateFlowResponseFilterSensitiveLog).ser(se_UpdateFlowCommand).de(de_UpdateFlowCommand).build() {
+};
+__name(_UpdateFlowCommand, "UpdateFlowCommand");
+var UpdateFlowCommand = _UpdateFlowCommand;
+
 // src/commands/UpdateKnowledgeBaseCommand.ts
 
 
@@ -2929,6 +4776,22 @@ var _UpdateKnowledgeBaseCommand = class _UpdateKnowledgeBaseCommand extends impo
 __name(_UpdateKnowledgeBaseCommand, "UpdateKnowledgeBaseCommand");
 var UpdateKnowledgeBaseCommand = _UpdateKnowledgeBaseCommand;
 
+// src/commands/UpdatePromptCommand.ts
+
+
+
+var _UpdatePromptCommand = class _UpdatePromptCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockAgentBuildTimeLambda", "UpdatePrompt", {}).n("BedrockAgentClient", "UpdatePromptCommand").f(UpdatePromptRequestFilterSensitiveLog, UpdatePromptResponseFilterSensitiveLog).ser(se_UpdatePromptCommand).de(de_UpdatePromptCommand).build() {
+};
+__name(_UpdatePromptCommand, "UpdatePromptCommand");
+var UpdatePromptCommand = _UpdatePromptCommand;
+
 // src/BedrockAgent.ts
 var commands = {
   AssociateAgentKnowledgeBaseCommand,
@@ -2936,13 +4799,22 @@ var commands = {
   CreateAgentActionGroupCommand,
   CreateAgentAliasCommand,
   CreateDataSourceCommand,
+  CreateFlowCommand,
+  CreateFlowAliasCommand,
+  CreateFlowVersionCommand,
   CreateKnowledgeBaseCommand,
+  CreatePromptCommand,
+  CreatePromptVersionCommand,
   DeleteAgentCommand,
   DeleteAgentActionGroupCommand,
   DeleteAgentAliasCommand,
   DeleteAgentVersionCommand,
   DeleteDataSourceCommand,
+  DeleteFlowCommand,
+  DeleteFlowAliasCommand,
+  DeleteFlowVersionCommand,
   DeleteKnowledgeBaseCommand,
+  DeletePromptCommand,
   DisassociateAgentKnowledgeBaseCommand,
   GetAgentCommand,
   GetAgentActionGroupCommand,
@@ -2950,18 +4822,27 @@ var commands = {
   GetAgentKnowledgeBaseCommand,
   GetAgentVersionCommand,
   GetDataSourceCommand,
+  GetFlowCommand,
+  GetFlowAliasCommand,
+  GetFlowVersionCommand,
   GetIngestionJobCommand,
   GetKnowledgeBaseCommand,
+  GetPromptCommand,
   ListAgentActionGroupsCommand,
   ListAgentAliasesCommand,
   ListAgentKnowledgeBasesCommand,
   ListAgentsCommand,
   ListAgentVersionsCommand,
   ListDataSourcesCommand,
+  ListFlowAliasesCommand,
+  ListFlowsCommand,
+  ListFlowVersionsCommand,
   ListIngestionJobsCommand,
   ListKnowledgeBasesCommand,
+  ListPromptsCommand,
   ListTagsForResourceCommand,
   PrepareAgentCommand,
+  PrepareFlowCommand,
   StartIngestionJobCommand,
   TagResourceCommand,
   UntagResourceCommand,
@@ -2970,7 +4851,10 @@ var commands = {
   UpdateAgentAliasCommand,
   UpdateAgentKnowledgeBaseCommand,
   UpdateDataSourceCommand,
-  UpdateKnowledgeBaseCommand
+  UpdateFlowCommand,
+  UpdateFlowAliasCommand,
+  UpdateKnowledgeBaseCommand,
+  UpdatePromptCommand
 };
 var _BedrockAgent = class _BedrockAgent extends BedrockAgentClient {
 };
@@ -3002,6 +4886,18 @@ var paginateListAgents = (0, import_core.createPaginator)(BedrockAgentClient, Li
 
 var paginateListDataSources = (0, import_core.createPaginator)(BedrockAgentClient, ListDataSourcesCommand, "nextToken", "nextToken", "maxResults");
 
+// src/pagination/ListFlowAliasesPaginator.ts
+
+var paginateListFlowAliases = (0, import_core.createPaginator)(BedrockAgentClient, ListFlowAliasesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFlowVersionsPaginator.ts
+
+var paginateListFlowVersions = (0, import_core.createPaginator)(BedrockAgentClient, ListFlowVersionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFlowsPaginator.ts
+
+var paginateListFlows = (0, import_core.createPaginator)(BedrockAgentClient, ListFlowsCommand, "nextToken", "nextToken", "maxResults");
+
 // src/pagination/ListIngestionJobsPaginator.ts
 
 var paginateListIngestionJobs = (0, import_core.createPaginator)(BedrockAgentClient, ListIngestionJobsCommand, "nextToken", "nextToken", "maxResults");
@@ -3009,6 +4905,10 @@ var paginateListIngestionJobs = (0, import_core.createPaginator)(BedrockAgentCli
 // src/pagination/ListKnowledgeBasesPaginator.ts
 
 var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentClient, ListKnowledgeBasesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPromptsPaginator.ts
+
+var paginateListPrompts = (0, import_core.createPaginator)(BedrockAgentClient, ListPromptsCommand, "nextToken", "nextToken", "maxResults");
 // Annotate the CommonJS export names for ESM import in node:
 
 0 && (module.exports = {
@@ -3022,13 +4922,22 @@ var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentCl
   CreateAgentAliasCommand,
   CreateAgentCommand,
   CreateDataSourceCommand,
+  CreateFlowAliasCommand,
+  CreateFlowCommand,
+  CreateFlowVersionCommand,
   CreateKnowledgeBaseCommand,
+  CreatePromptCommand,
+  CreatePromptVersionCommand,
   DeleteAgentActionGroupCommand,
   DeleteAgentAliasCommand,
   DeleteAgentCommand,
   DeleteAgentVersionCommand,
   DeleteDataSourceCommand,
+  DeleteFlowAliasCommand,
+  DeleteFlowCommand,
+  DeleteFlowVersionCommand,
   DeleteKnowledgeBaseCommand,
+  DeletePromptCommand,
   DisassociateAgentKnowledgeBaseCommand,
   GetAgentActionGroupCommand,
   GetAgentAliasCommand,
@@ -3036,18 +4945,27 @@ var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentCl
   GetAgentKnowledgeBaseCommand,
   GetAgentVersionCommand,
   GetDataSourceCommand,
+  GetFlowAliasCommand,
+  GetFlowCommand,
+  GetFlowVersionCommand,
   GetIngestionJobCommand,
   GetKnowledgeBaseCommand,
+  GetPromptCommand,
   ListAgentActionGroupsCommand,
   ListAgentAliasesCommand,
   ListAgentKnowledgeBasesCommand,
   ListAgentVersionsCommand,
   ListAgentsCommand,
   ListDataSourcesCommand,
+  ListFlowAliasesCommand,
+  ListFlowVersionsCommand,
+  ListFlowsCommand,
   ListIngestionJobsCommand,
   ListKnowledgeBasesCommand,
+  ListPromptsCommand,
   ListTagsForResourceCommand,
   PrepareAgentCommand,
+  PrepareFlowCommand,
   StartIngestionJobCommand,
   TagResourceCommand,
   UntagResourceCommand,
@@ -3056,15 +4974,22 @@ var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentCl
   UpdateAgentCommand,
   UpdateAgentKnowledgeBaseCommand,
   UpdateDataSourceCommand,
+  UpdateFlowAliasCommand,
+  UpdateFlowCommand,
   UpdateKnowledgeBaseCommand,
+  UpdatePromptCommand,
   paginateListAgentActionGroups,
   paginateListAgentAliases,
   paginateListAgentKnowledgeBases,
   paginateListAgentVersions,
   paginateListAgents,
   paginateListDataSources,
+  paginateListFlowAliases,
+  paginateListFlowVersions,
+  paginateListFlows,
   paginateListIngestionJobs,
   paginateListKnowledgeBases,
+  paginateListPrompts,
   AccessDeniedException,
   CustomControlMethod,
   ActionGroupExecutor,
@@ -3080,15 +5005,38 @@ var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentCl
   ThrottlingException,
   ValidationException,
   AgentStatus,
+  MemoryType,
   CreationMode,
   PromptState,
   PromptType,
   AgentAliasStatus,
   KnowledgeBaseState,
   DataDeletionPolicy,
+  CrawlFilterConfigurationType,
+  ConfluenceAuthType,
+  ConfluenceHostType,
+  SalesforceAuthType,
+  SharePointAuthType,
+  SharePointHostType,
   DataSourceType,
+  WebScopeType,
   ChunkingStrategy,
+  StepType,
+  ParsingStrategy,
   DataSourceStatus,
+  FlowConnectionConfiguration,
+  FlowConnectionType,
+  PromptInferenceConfiguration,
+  PromptTemplateConfiguration,
+  PromptTemplateType,
+  PromptFlowNodeSourceConfiguration,
+  RetrievalFlowNodeServiceConfiguration,
+  StorageFlowNodeServiceConfiguration,
+  FlowNodeConfiguration,
+  FlowNodeIODataType,
+  FlowNodeType,
+  FlowStatus,
+  FlowValidationSeverity,
   IngestionJobStatus,
   IngestionJobFilterAttribute,
   IngestionJobFilterOperator,
@@ -3104,6 +5052,7 @@ var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentCl
   GetAgentActionGroupResponseFilterSensitiveLog,
   UpdateAgentActionGroupRequestFilterSensitiveLog,
   UpdateAgentActionGroupResponseFilterSensitiveLog,
+  PromptConfigurationFilterSensitiveLog,
   PromptOverrideConfigurationFilterSensitiveLog,
   AgentFilterSensitiveLog,
   CreateAgentRequestFilterSensitiveLog,
@@ -3112,6 +5061,50 @@ var paginateListKnowledgeBases = (0, import_core.createPaginator)(BedrockAgentCl
   UpdateAgentRequestFilterSensitiveLog,
   UpdateAgentResponseFilterSensitiveLog,
   AgentVersionFilterSensitiveLog,
+  PatternObjectFilterFilterSensitiveLog,
+  PatternObjectFilterConfigurationFilterSensitiveLog,
+  CrawlFilterConfigurationFilterSensitiveLog,
+  ConfluenceCrawlerConfigurationFilterSensitiveLog,
+  ConfluenceDataSourceConfigurationFilterSensitiveLog,
+  S3DataSourceConfigurationFilterSensitiveLog,
+  SalesforceCrawlerConfigurationFilterSensitiveLog,
+  SalesforceDataSourceConfigurationFilterSensitiveLog,
+  SharePointCrawlerConfigurationFilterSensitiveLog,
+  SharePointDataSourceConfigurationFilterSensitiveLog,
+  WebCrawlerConfigurationFilterSensitiveLog,
+  WebDataSourceConfigurationFilterSensitiveLog,
+  DataSourceConfigurationFilterSensitiveLog,
+  CreateDataSourceRequestFilterSensitiveLog,
+  DataSourceFilterSensitiveLog,
+  CreateDataSourceResponseFilterSensitiveLog,
+  GetDataSourceResponseFilterSensitiveLog,
+  UpdateDataSourceRequestFilterSensitiveLog,
+  UpdateDataSourceResponseFilterSensitiveLog,
+  FlowConditionFilterSensitiveLog,
+  ConditionFlowNodeConfigurationFilterSensitiveLog,
+  TextPromptTemplateConfigurationFilterSensitiveLog,
+  PromptTemplateConfigurationFilterSensitiveLog,
+  PromptFlowNodeInlineConfigurationFilterSensitiveLog,
+  PromptFlowNodeSourceConfigurationFilterSensitiveLog,
+  PromptFlowNodeConfigurationFilterSensitiveLog,
+  FlowNodeConfigurationFilterSensitiveLog,
+  FlowNodeInputFilterSensitiveLog,
+  FlowNodeFilterSensitiveLog,
+  FlowDefinitionFilterSensitiveLog,
+  CreateFlowRequestFilterSensitiveLog,
+  CreateFlowResponseFilterSensitiveLog,
+  CreateFlowVersionResponseFilterSensitiveLog,
+  GetFlowVersionResponseFilterSensitiveLog,
+  GetFlowResponseFilterSensitiveLog,
+  UpdateFlowRequestFilterSensitiveLog,
+  UpdateFlowResponseFilterSensitiveLog,
+  PromptVariantFilterSensitiveLog,
+  CreatePromptRequestFilterSensitiveLog,
+  CreatePromptResponseFilterSensitiveLog,
+  CreatePromptVersionResponseFilterSensitiveLog,
+  GetPromptResponseFilterSensitiveLog,
+  UpdatePromptRequestFilterSensitiveLog,
+  UpdatePromptResponseFilterSensitiveLog,
   GetAgentVersionResponseFilterSensitiveLog
 });