@aws-sdk/client-bedrock-agent 3.934.0 → 3.935.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,938 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const CustomControlMethod: {
+    readonly RETURN_CONTROL: "RETURN_CONTROL";
+};
+/**
+ * @public
+ */
+export type CustomControlMethod = (typeof CustomControlMethod)[keyof typeof CustomControlMethod];
+/**
+ * @public
+ * @enum
+ */
+export declare const ActionGroupState: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type ActionGroupState = (typeof ActionGroupState)[keyof typeof ActionGroupState];
+/**
+ * @public
+ * @enum
+ */
+export declare const Type: {
+    readonly ARRAY: "array";
+    readonly BOOLEAN: "boolean";
+    readonly INTEGER: "integer";
+    readonly NUMBER: "number";
+    readonly STRING: "string";
+};
+/**
+ * @public
+ */
+export type Type = (typeof Type)[keyof typeof Type];
+/**
+ * @public
+ * @enum
+ */
+export declare const RequireConfirmation: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type RequireConfirmation = (typeof RequireConfirmation)[keyof typeof RequireConfirmation];
+/**
+ * @public
+ * @enum
+ */
+export declare const ActionGroupSignature: {
+    readonly AMAZON_CODEINTERPRETER: "AMAZON.CodeInterpreter";
+    readonly AMAZON_USERINPUT: "AMAZON.UserInput";
+    readonly ANTHROPIC_BASH: "ANTHROPIC.Bash";
+    readonly ANTHROPIC_COMPUTER: "ANTHROPIC.Computer";
+    readonly ANTHROPIC_TEXTEDITOR: "ANTHROPIC.TextEditor";
+};
+/**
+ * @public
+ */
+export type ActionGroupSignature = (typeof ActionGroupSignature)[keyof typeof ActionGroupSignature];
+/**
+ * @public
+ * @enum
+ */
+export declare const AgentCollaboration: {
+    readonly DISABLED: "DISABLED";
+    readonly SUPERVISOR: "SUPERVISOR";
+    readonly SUPERVISOR_ROUTER: "SUPERVISOR_ROUTER";
+};
+/**
+ * @public
+ */
+export type AgentCollaboration = (typeof AgentCollaboration)[keyof typeof AgentCollaboration];
+/**
+ * @public
+ * @enum
+ */
+export declare const AgentStatus: {
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+    readonly NOT_PREPARED: "NOT_PREPARED";
+    readonly PREPARED: "PREPARED";
+    readonly PREPARING: "PREPARING";
+    readonly UPDATING: "UPDATING";
+    readonly VERSIONING: "VERSIONING";
+};
+/**
+ * @public
+ */
+export type AgentStatus = (typeof AgentStatus)[keyof typeof AgentStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const MemoryType: {
+    readonly SESSION_SUMMARY: "SESSION_SUMMARY";
+};
+/**
+ * @public
+ */
+export type MemoryType = (typeof MemoryType)[keyof typeof MemoryType];
+/**
+ * @public
+ * @enum
+ */
+export declare const OrchestrationType: {
+    readonly CUSTOM_ORCHESTRATION: "CUSTOM_ORCHESTRATION";
+    readonly DEFAULT: "DEFAULT";
+};
+/**
+ * @public
+ */
+export type OrchestrationType = (typeof OrchestrationType)[keyof typeof OrchestrationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CreationMode: {
+    readonly DEFAULT: "DEFAULT";
+    readonly OVERRIDDEN: "OVERRIDDEN";
+};
+/**
+ * @public
+ */
+export type CreationMode = (typeof CreationMode)[keyof typeof CreationMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const PromptState: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type PromptState = (typeof PromptState)[keyof typeof PromptState];
+/**
+ * @public
+ * @enum
+ */
+export declare const PromptType: {
+    readonly KNOWLEDGE_BASE_RESPONSE_GENERATION: "KNOWLEDGE_BASE_RESPONSE_GENERATION";
+    readonly MEMORY_SUMMARIZATION: "MEMORY_SUMMARIZATION";
+    readonly ORCHESTRATION: "ORCHESTRATION";
+    readonly POST_PROCESSING: "POST_PROCESSING";
+    readonly PRE_PROCESSING: "PRE_PROCESSING";
+};
+/**
+ * @public
+ */
+export type PromptType = (typeof PromptType)[keyof typeof PromptType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AgentAliasStatus: {
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly DISSOCIATED: "DISSOCIATED";
+    readonly FAILED: "FAILED";
+    readonly PREPARED: "PREPARED";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type AgentAliasStatus = (typeof AgentAliasStatus)[keyof typeof AgentAliasStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const AliasInvocationState: {
+    /**
+     * Agent is actively processing requests
+     */
+    readonly ACCEPT_INVOCATIONS: "ACCEPT_INVOCATIONS";
+    /**
+     * Agent is paused and will not accept new requests
+     */
+    readonly REJECT_INVOCATIONS: "REJECT_INVOCATIONS";
+};
+/**
+ * @public
+ */
+export type AliasInvocationState = (typeof AliasInvocationState)[keyof typeof AliasInvocationState];
+/**
+ * @public
+ * @enum
+ */
+export declare const RelayConversationHistory: {
+    readonly DISABLED: "DISABLED";
+    readonly TO_COLLABORATOR: "TO_COLLABORATOR";
+};
+/**
+ * @public
+ */
+export type RelayConversationHistory = (typeof RelayConversationHistory)[keyof typeof RelayConversationHistory];
+/**
+ * @public
+ * @enum
+ */
+export declare const KnowledgeBaseState: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type KnowledgeBaseState = (typeof KnowledgeBaseState)[keyof typeof KnowledgeBaseState];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataDeletionPolicy: {
+    readonly DELETE: "DELETE";
+    readonly RETAIN: "RETAIN";
+};
+/**
+ * @public
+ */
+export type DataDeletionPolicy = (typeof DataDeletionPolicy)[keyof typeof DataDeletionPolicy];
+/**
+ * @public
+ * @enum
+ */
+export declare const CrawlFilterConfigurationType: {
+    readonly PATTERN: "PATTERN";
+};
+/**
+ * @public
+ */
+export type CrawlFilterConfigurationType = (typeof CrawlFilterConfigurationType)[keyof typeof CrawlFilterConfigurationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConfluenceAuthType: {
+    readonly BASIC: "BASIC";
+    readonly OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS";
+};
+/**
+ * @public
+ */
+export type ConfluenceAuthType = (typeof ConfluenceAuthType)[keyof typeof ConfluenceAuthType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConfluenceHostType: {
+    readonly SAAS: "SAAS";
+};
+/**
+ * @public
+ */
+export type ConfluenceHostType = (typeof ConfluenceHostType)[keyof typeof ConfluenceHostType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SalesforceAuthType: {
+    readonly OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS";
+};
+/**
+ * @public
+ */
+export type SalesforceAuthType = (typeof SalesforceAuthType)[keyof typeof SalesforceAuthType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SharePointAuthType: {
+    readonly OAUTH2_CLIENT_CREDENTIALS: "OAUTH2_CLIENT_CREDENTIALS";
+    readonly OAUTH2_SHAREPOINT_APP_ONLY_CLIENT_CREDENTIALS: "OAUTH2_SHAREPOINT_APP_ONLY_CLIENT_CREDENTIALS";
+};
+/**
+ * @public
+ */
+export type SharePointAuthType = (typeof SharePointAuthType)[keyof typeof SharePointAuthType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SharePointHostType: {
+    readonly ONLINE: "ONLINE";
+};
+/**
+ * @public
+ */
+export type SharePointHostType = (typeof SharePointHostType)[keyof typeof SharePointHostType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataSourceType: {
+    readonly CONFLUENCE: "CONFLUENCE";
+    readonly CUSTOM: "CUSTOM";
+    readonly REDSHIFT_METADATA: "REDSHIFT_METADATA";
+    readonly S3: "S3";
+    readonly SALESFORCE: "SALESFORCE";
+    readonly SHAREPOINT: "SHAREPOINT";
+    readonly WEB: "WEB";
+};
+/**
+ * @public
+ */
+export type DataSourceType = (typeof DataSourceType)[keyof typeof DataSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const WebScopeType: {
+    readonly HOST_ONLY: "HOST_ONLY";
+    readonly SUBDOMAINS: "SUBDOMAINS";
+};
+/**
+ * @public
+ */
+export type WebScopeType = (typeof WebScopeType)[keyof typeof WebScopeType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChunkingStrategy: {
+    readonly FIXED_SIZE: "FIXED_SIZE";
+    readonly HIERARCHICAL: "HIERARCHICAL";
+    readonly NONE: "NONE";
+    readonly SEMANTIC: "SEMANTIC";
+};
+/**
+ * @public
+ */
+export type ChunkingStrategy = (typeof ChunkingStrategy)[keyof typeof ChunkingStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const EnrichmentStrategyMethod: {
+    readonly CHUNK_ENTITY_EXTRACTION: "CHUNK_ENTITY_EXTRACTION";
+};
+/**
+ * @public
+ */
+export type EnrichmentStrategyMethod = (typeof EnrichmentStrategyMethod)[keyof typeof EnrichmentStrategyMethod];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContextEnrichmentType: {
+    readonly BEDROCK_FOUNDATION_MODEL: "BEDROCK_FOUNDATION_MODEL";
+};
+/**
+ * @public
+ */
+export type ContextEnrichmentType = (typeof ContextEnrichmentType)[keyof typeof ContextEnrichmentType];
+/**
+ * @public
+ * @enum
+ */
+export declare const StepType: {
+    readonly POST_CHUNKING: "POST_CHUNKING";
+};
+/**
+ * @public
+ */
+export type StepType = (typeof StepType)[keyof typeof StepType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ParsingModality: {
+    readonly MULTIMODAL: "MULTIMODAL";
+};
+/**
+ * @public
+ */
+export type ParsingModality = (typeof ParsingModality)[keyof typeof ParsingModality];
+/**
+ * @public
+ * @enum
+ */
+export declare const ParsingStrategy: {
+    readonly BEDROCK_DATA_AUTOMATION: "BEDROCK_DATA_AUTOMATION";
+    readonly BEDROCK_FOUNDATION_MODEL: "BEDROCK_FOUNDATION_MODEL";
+};
+/**
+ * @public
+ */
+export type ParsingStrategy = (typeof ParsingStrategy)[keyof typeof ParsingStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataSourceStatus: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly DELETE_UNSUCCESSFUL: "DELETE_UNSUCCESSFUL";
+    readonly DELETING: "DELETING";
+};
+/**
+ * @public
+ */
+export type DataSourceStatus = (typeof DataSourceStatus)[keyof typeof DataSourceStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowConnectionType: {
+    readonly CONDITIONAL: "Conditional";
+    readonly DATA: "Data";
+};
+/**
+ * @public
+ */
+export type FlowConnectionType = (typeof FlowConnectionType)[keyof typeof FlowConnectionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SupportedLanguages: {
+    readonly PYTHON_3: "Python_3";
+};
+/**
+ * @public
+ */
+export type SupportedLanguages = (typeof SupportedLanguages)[keyof typeof SupportedLanguages];
+/**
+ * @public
+ * @enum
+ */
+export declare const PerformanceConfigLatency: {
+    readonly OPTIMIZED: "optimized";
+    readonly STANDARD: "standard";
+};
+/**
+ * @public
+ */
+export type PerformanceConfigLatency = (typeof PerformanceConfigLatency)[keyof typeof PerformanceConfigLatency];
+/**
+ * @public
+ * @enum
+ */
+export declare const RerankingMetadataSelectionMode: {
+    readonly ALL: "ALL";
+    readonly SELECTIVE: "SELECTIVE";
+};
+/**
+ * @public
+ */
+export type RerankingMetadataSelectionMode = (typeof RerankingMetadataSelectionMode)[keyof typeof RerankingMetadataSelectionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const VectorSearchRerankingConfigurationType: {
+    readonly BEDROCK_RERANKING_MODEL: "BEDROCK_RERANKING_MODEL";
+};
+/**
+ * @public
+ */
+export type VectorSearchRerankingConfigurationType = (typeof VectorSearchRerankingConfigurationType)[keyof typeof VectorSearchRerankingConfigurationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CachePointType: {
+    readonly DEFAULT: "default";
+};
+/**
+ * @public
+ */
+export type CachePointType = (typeof CachePointType)[keyof typeof CachePointType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConversationRole: {
+    readonly ASSISTANT: "assistant";
+    readonly USER: "user";
+};
+/**
+ * @public
+ */
+export type ConversationRole = (typeof ConversationRole)[keyof typeof ConversationRole];
+/**
+ * @public
+ * @enum
+ */
+export declare const PromptTemplateType: {
+    readonly CHAT: "CHAT";
+    readonly TEXT: "TEXT";
+};
+/**
+ * @public
+ */
+export type PromptTemplateType = (typeof PromptTemplateType)[keyof typeof PromptTemplateType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowNodeInputCategory: {
+    readonly EXIT_LOOP: "ExitLoop";
+    readonly LOOP_CONDITION: "LoopCondition";
+    readonly RETURN_VALUE_TO_LOOP_START: "ReturnValueToLoopStart";
+};
+/**
+ * @public
+ */
+export type FlowNodeInputCategory = (typeof FlowNodeInputCategory)[keyof typeof FlowNodeInputCategory];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowNodeIODataType: {
+    readonly ARRAY: "Array";
+    readonly BOOLEAN: "Boolean";
+    readonly NUMBER: "Number";
+    readonly OBJECT: "Object";
+    readonly STRING: "String";
+};
+/**
+ * @public
+ */
+export type FlowNodeIODataType = (typeof FlowNodeIODataType)[keyof typeof FlowNodeIODataType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowNodeType: {
+    readonly AGENT: "Agent";
+    readonly COLLECTOR: "Collector";
+    readonly CONDITION: "Condition";
+    readonly INLINE_CODE: "InlineCode";
+    readonly INPUT: "Input";
+    readonly ITERATOR: "Iterator";
+    readonly KNOWLEDGE_BASE: "KnowledgeBase";
+    readonly LAMBDA_FUNCTION: "LambdaFunction";
+    readonly LEX: "Lex";
+    readonly LOOP: "Loop";
+    readonly LOOP_CONTROLLER: "LoopController";
+    readonly LOOP_INPUT: "LoopInput";
+    readonly OUTPUT: "Output";
+    readonly PROMPT: "Prompt";
+    readonly RETRIEVAL: "Retrieval";
+    readonly STORAGE: "Storage";
+};
+/**
+ * @public
+ */
+export type FlowNodeType = (typeof FlowNodeType)[keyof typeof FlowNodeType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowStatus: {
+    readonly FAILED: "Failed";
+    readonly NOT_PREPARED: "NotPrepared";
+    readonly PREPARED: "Prepared";
+    readonly PREPARING: "Preparing";
+};
+/**
+ * @public
+ */
+export type FlowStatus = (typeof FlowStatus)[keyof typeof FlowStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConcurrencyType: {
+    readonly AUTOMATIC: "Automatic";
+    readonly MANUAL: "Manual";
+};
+/**
+ * @public
+ */
+export type ConcurrencyType = (typeof ConcurrencyType)[keyof typeof ConcurrencyType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IncompatibleLoopNodeType: {
+    readonly COLLECTOR: "Collector";
+    readonly CONDITION: "Condition";
+    readonly INPUT: "Input";
+    readonly ITERATOR: "Iterator";
+};
+/**
+ * @public
+ */
+export type IncompatibleLoopNodeType = (typeof IncompatibleLoopNodeType)[keyof typeof IncompatibleLoopNodeType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowValidationSeverity: {
+    readonly ERROR: "Error";
+    readonly WARNING: "Warning";
+};
+/**
+ * @public
+ */
+export type FlowValidationSeverity = (typeof FlowValidationSeverity)[keyof typeof FlowValidationSeverity];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowValidationType: {
+    readonly CYCLIC_CONNECTION: "CyclicConnection";
+    readonly DUPLICATE_CONDITION_EXPRESSION: "DuplicateConditionExpression";
+    readonly DUPLICATE_CONNECTIONS: "DuplicateConnections";
+    readonly INCOMPATIBLE_CONNECTION_DATA_TYPE: "IncompatibleConnectionDataType";
+    readonly INVALID_LOOP_BOUNDARY: "InvalidLoopBoundary";
+    readonly LOOP_INCOMPATIBLE_NODE_TYPE: "LoopIncompatibleNodeType";
+    readonly MALFORMED_CONDITION_EXPRESSION: "MalformedConditionExpression";
+    readonly MALFORMED_NODE_INPUT_EXPRESSION: "MalformedNodeInputExpression";
+    readonly MISMATCHED_NODE_INPUT_TYPE: "MismatchedNodeInputType";
+    readonly MISMATCHED_NODE_OUTPUT_TYPE: "MismatchedNodeOutputType";
+    readonly MISSING_CONNECTION_CONFIGURATION: "MissingConnectionConfiguration";
+    readonly MISSING_DEFAULT_CONDITION: "MissingDefaultCondition";
+    readonly MISSING_ENDING_NODES: "MissingEndingNodes";
+    readonly MISSING_LOOP_CONTROLLER_NODE: "MissingLoopControllerNode";
+    readonly MISSING_LOOP_INPUT_NODE: "MissingLoopInputNode";
+    readonly MISSING_NODE_CONFIGURATION: "MissingNodeConfiguration";
+    readonly MISSING_NODE_INPUT: "MissingNodeInput";
+    readonly MISSING_NODE_OUTPUT: "MissingNodeOutput";
+    readonly MISSING_STARTING_NODES: "MissingStartingNodes";
+    readonly MULTIPLE_LOOP_CONTROLLER_NODES: "MultipleLoopControllerNodes";
+    readonly MULTIPLE_LOOP_INPUT_NODES: "MultipleLoopInputNodes";
+    readonly MULTIPLE_NODE_INPUT_CONNECTIONS: "MultipleNodeInputConnections";
+    readonly UNFULFILLED_NODE_INPUT: "UnfulfilledNodeInput";
+    readonly UNKNOWN_CONNECTION_CONDITION: "UnknownConnectionCondition";
+    readonly UNKNOWN_CONNECTION_SOURCE: "UnknownConnectionSource";
+    readonly UNKNOWN_CONNECTION_SOURCE_OUTPUT: "UnknownConnectionSourceOutput";
+    readonly UNKNOWN_CONNECTION_TARGET: "UnknownConnectionTarget";
+    readonly UNKNOWN_CONNECTION_TARGET_INPUT: "UnknownConnectionTargetInput";
+    readonly UNKNOWN_NODE_INPUT: "UnknownNodeInput";
+    readonly UNKNOWN_NODE_OUTPUT: "UnknownNodeOutput";
+    readonly UNREACHABLE_NODE: "UnreachableNode";
+    readonly UNSATISFIED_CONNECTION_CONDITIONS: "UnsatisfiedConnectionConditions";
+    readonly UNSPECIFIED: "Unspecified";
+};
+/**
+ * @public
+ */
+export type FlowValidationType = (typeof FlowValidationType)[keyof typeof FlowValidationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IngestionJobStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly STARTING: "STARTING";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+};
+/**
+ * @public
+ */
+export type IngestionJobStatus = (typeof IngestionJobStatus)[keyof typeof IngestionJobStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const IngestionJobFilterAttribute: {
+    readonly STATUS: "STATUS";
+};
+/**
+ * @public
+ */
+export type IngestionJobFilterAttribute = (typeof IngestionJobFilterAttribute)[keyof typeof IngestionJobFilterAttribute];
+/**
+ * @public
+ * @enum
+ */
+export declare const IngestionJobFilterOperator: {
+    readonly EQ: "EQ";
+};
+/**
+ * @public
+ */
+export type IngestionJobFilterOperator = (typeof IngestionJobFilterOperator)[keyof typeof IngestionJobFilterOperator];
+/**
+ * @public
+ * @enum
+ */
+export declare const IngestionJobSortByAttribute: {
+    readonly STARTED_AT: "STARTED_AT";
+    readonly STATUS: "STATUS";
+};
+/**
+ * @public
+ */
+export type IngestionJobSortByAttribute = (typeof IngestionJobSortByAttribute)[keyof typeof IngestionJobSortByAttribute];
+/**
+ * @public
+ * @enum
+ */
+export declare const SortOrder: {
+    readonly ASCENDING: "ASCENDING";
+    readonly DESCENDING: "DESCENDING";
+};
+/**
+ * @public
+ */
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContentDataSourceType: {
+    readonly CUSTOM: "CUSTOM";
+    readonly S3: "S3";
+};
+/**
+ * @public
+ */
+export type ContentDataSourceType = (typeof ContentDataSourceType)[keyof typeof ContentDataSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DocumentStatus: {
+    readonly DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+    readonly IGNORED: "IGNORED";
+    readonly INDEXED: "INDEXED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly METADATA_PARTIALLY_INDEXED: "METADATA_PARTIALLY_INDEXED";
+    readonly METADATA_UPDATE_FAILED: "METADATA_UPDATE_FAILED";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly PARTIALLY_INDEXED: "PARTIALLY_INDEXED";
+    readonly PENDING: "PENDING";
+    readonly STARTING: "STARTING";
+};
+/**
+ * @public
+ */
+export type DocumentStatus = (typeof DocumentStatus)[keyof typeof DocumentStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const InlineContentType: {
+    readonly BYTE: "BYTE";
+    readonly TEXT: "TEXT";
+};
+/**
+ * @public
+ */
+export type InlineContentType = (typeof InlineContentType)[keyof typeof InlineContentType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CustomSourceType: {
+    readonly IN_LINE: "IN_LINE";
+    readonly S3_LOCATION: "S3_LOCATION";
+};
+/**
+ * @public
+ */
+export type CustomSourceType = (typeof CustomSourceType)[keyof typeof CustomSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const MetadataValueType: {
+    readonly BOOLEAN: "BOOLEAN";
+    readonly NUMBER: "NUMBER";
+    readonly STRING: "STRING";
+    readonly STRING_LIST: "STRING_LIST";
+};
+/**
+ * @public
+ */
+export type MetadataValueType = (typeof MetadataValueType)[keyof typeof MetadataValueType];
+/**
+ * @public
+ * @enum
+ */
+export declare const MetadataSourceType: {
+    readonly IN_LINE_ATTRIBUTE: "IN_LINE_ATTRIBUTE";
+    readonly S3_LOCATION: "S3_LOCATION";
+};
+/**
+ * @public
+ */
+export type MetadataSourceType = (typeof MetadataSourceType)[keyof typeof MetadataSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RedshiftProvisionedAuthType: {
+    readonly IAM: "IAM";
+    readonly USERNAME: "USERNAME";
+    readonly USERNAME_PASSWORD: "USERNAME_PASSWORD";
+};
+/**
+ * @public
+ */
+export type RedshiftProvisionedAuthType = (typeof RedshiftProvisionedAuthType)[keyof typeof RedshiftProvisionedAuthType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RedshiftServerlessAuthType: {
+    readonly IAM: "IAM";
+    readonly USERNAME_PASSWORD: "USERNAME_PASSWORD";
+};
+/**
+ * @public
+ */
+export type RedshiftServerlessAuthType = (typeof RedshiftServerlessAuthType)[keyof typeof RedshiftServerlessAuthType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RedshiftQueryEngineType: {
+    readonly PROVISIONED: "PROVISIONED";
+    readonly SERVERLESS: "SERVERLESS";
+};
+/**
+ * @public
+ */
+export type RedshiftQueryEngineType = (typeof RedshiftQueryEngineType)[keyof typeof RedshiftQueryEngineType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IncludeExclude: {
+    readonly EXCLUDE: "EXCLUDE";
+    readonly INCLUDE: "INCLUDE";
+};
+/**
+ * @public
+ */
+export type IncludeExclude = (typeof IncludeExclude)[keyof typeof IncludeExclude];
+/**
+ * @public
+ * @enum
+ */
+export declare const RedshiftQueryEngineStorageType: {
+    readonly AWS_DATA_CATALOG: "AWS_DATA_CATALOG";
+    readonly REDSHIFT: "REDSHIFT";
+};
+/**
+ * @public
+ */
+export type RedshiftQueryEngineStorageType = (typeof RedshiftQueryEngineStorageType)[keyof typeof RedshiftQueryEngineStorageType];
+/**
+ * @public
+ * @enum
+ */
+export declare const QueryEngineType: {
+    readonly REDSHIFT: "REDSHIFT";
+};
+/**
+ * @public
+ */
+export type QueryEngineType = (typeof QueryEngineType)[keyof typeof QueryEngineType];
+/**
+ * @public
+ * @enum
+ */
+export declare const KnowledgeBaseType: {
+    readonly KENDRA: "KENDRA";
+    readonly SQL: "SQL";
+    readonly VECTOR: "VECTOR";
+};
+/**
+ * @public
+ */
+export type KnowledgeBaseType = (typeof KnowledgeBaseType)[keyof typeof KnowledgeBaseType];
+/**
+ * @public
+ * @enum
+ */
+export declare const EmbeddingDataType: {
+    readonly BINARY: "BINARY";
+    readonly FLOAT32: "FLOAT32";
+};
+/**
+ * @public
+ */
+export type EmbeddingDataType = (typeof EmbeddingDataType)[keyof typeof EmbeddingDataType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SupplementalDataStorageLocationType: {
+    readonly S3: "S3";
+};
+/**
+ * @public
+ */
+export type SupplementalDataStorageLocationType = (typeof SupplementalDataStorageLocationType)[keyof typeof SupplementalDataStorageLocationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const KnowledgeBaseStorageType: {
+    readonly MONGO_DB_ATLAS: "MONGO_DB_ATLAS";
+    readonly NEPTUNE_ANALYTICS: "NEPTUNE_ANALYTICS";
+    readonly OPENSEARCH_MANAGED_CLUSTER: "OPENSEARCH_MANAGED_CLUSTER";
+    readonly OPENSEARCH_SERVERLESS: "OPENSEARCH_SERVERLESS";
+    readonly PINECONE: "PINECONE";
+    readonly RDS: "RDS";
+    readonly REDIS_ENTERPRISE_CLOUD: "REDIS_ENTERPRISE_CLOUD";
+    readonly S3_VECTORS: "S3_VECTORS";
+};
+/**
+ * @public
+ */
+export type KnowledgeBaseStorageType = (typeof KnowledgeBaseStorageType)[keyof typeof KnowledgeBaseStorageType];
+/**
+ * @public
+ * @enum
+ */
+export declare const KnowledgeBaseStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CREATING: "CREATING";
+    readonly DELETE_UNSUCCESSFUL: "DELETE_UNSUCCESSFUL";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type KnowledgeBaseStatus = (typeof KnowledgeBaseStatus)[keyof typeof KnowledgeBaseStatus];