@stacksjs/ts-cloud 0.2.3 → 0.2.5

package/dist/aws/bedrock.d.ts

@@ -0,0 +1,2672 @@
+/**
+ * AWS Bedrock Client
+ * Direct API calls for Bedrock AI model invocations and management
+ * No external SDK dependencies - implements AWS Signature V4 directly
+ */
+export interface BedrockMessage {
+    role: 'user' | 'assistant';
+    content: string | BedrockContentBlock[];
+}
+export type BedrockContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: BedrockImageSource;
+} | {
+    type: 'document';
+    source: BedrockDocumentSource;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | BedrockContentBlock[];
+};
+export interface BedrockImageSource {
+    type: 'base64';
+    media_type: 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp';
+    data: string;
+}
+export interface BedrockDocumentSource {
+    type: 'base64';
+    media_type: 'application/pdf';
+    data: string;
+}
+export interface BedrockToolDefinition {
+    name: string;
+    description?: string;
+    input_schema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export interface BedrockResponse {
+    id: string;
+    type: string;
+    role: string;
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'tool_use';
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }>;
+    model: string;
+    stop_reason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence';
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export interface InvokeModelCommandInput {
+    modelId: string;
+    body: string | Uint8Array | Record<string, unknown>;
+    contentType?: string;
+    accept?: string;
+    trace?: 'ENABLED' | 'DISABLED';
+    guardrailIdentifier?: string;
+    guardrailVersion?: string;
+}
+export interface InvokeModelCommandOutput {
+    body: Uint8Array;
+    contentType: string;
+}
+export interface InvokeModelWithResponseStreamCommandInput {
+    modelId: string;
+    body: string | Uint8Array | Record<string, unknown>;
+    contentType?: string;
+    accept?: string;
+    trace?: 'ENABLED' | 'DISABLED';
+    guardrailIdentifier?: string;
+    guardrailVersion?: string;
+}
+export interface InvokeModelWithResponseStreamCommandOutput {
+    body: AsyncIterable<BedrockStreamChunk>;
+    contentType: string;
+}
+export interface BedrockStreamChunk {
+    chunk?: {
+        bytes: Uint8Array;
+    };
+    internalServerException?: {
+        message: string;
+    };
+    modelStreamErrorException?: {
+        message: string;
+        originalStatusCode?: number;
+        originalMessage?: string;
+    };
+    modelTimeoutException?: {
+        message: string;
+    };
+    throttlingException?: {
+        message: string;
+    };
+    validationException?: {
+        message: string;
+    };
+}
+export interface ConverseCommandInput {
+    modelId: string;
+    messages: BedrockMessage[];
+    system?: Array<{
+        text: string;
+    }>;
+    inferenceConfig?: {
+        maxTokens?: number;
+        temperature?: number;
+        topP?: number;
+        stopSequences?: string[];
+    };
+    toolConfig?: {
+        tools: Array<{
+            toolSpec: BedrockToolDefinition;
+        }>;
+        toolChoice?: {
+            auto: Record<string, never>;
+        } | {
+            any: Record<string, never>;
+        } | {
+            tool: {
+                name: string;
+            };
+        };
+    };
+    guardrailConfig?: {
+        guardrailIdentifier: string;
+        guardrailVersion: string;
+        trace?: 'enabled' | 'disabled';
+    };
+}
+export interface ConverseCommandOutput {
+    output: {
+        message?: BedrockMessage;
+    };
+    stopReason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'guardrail_intervened' | 'content_filtered';
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    metrics?: {
+        latencyMs: number;
+    };
+}
+export interface CreateModelCustomizationJobCommandInput {
+    jobName: string;
+    customModelName: string;
+    roleArn: string;
+    baseModelIdentifier: string;
+    trainingDataConfig: {
+        s3Uri: string;
+    };
+    validationDataConfig?: {
+        validators: Array<{
+            s3Uri: string;
+        }>;
+    };
+    outputDataConfig: {
+        s3Uri: string;
+    };
+    hyperParameters?: Record<string, string>;
+    vpcConfig?: {
+        subnetIds: string[];
+        securityGroupIds: string[];
+    };
+    customModelKmsKeyId?: string;
+    customModelTags?: Array<{
+        key: string;
+        value: string;
+    }>;
+    customizationType?: 'FINE_TUNING' | 'CONTINUED_PRE_TRAINING';
+}
+export interface CreateModelCustomizationJobCommandOutput {
+    jobArn: string;
+}
+export interface GetModelCustomizationJobCommandInput {
+    jobIdentifier: string;
+}
+export interface GetModelCustomizationJobCommandOutput {
+    jobArn: string;
+    jobName: string;
+    outputModelName: string;
+    outputModelArn?: string;
+    clientRequestToken?: string;
+    roleArn: string;
+    status: 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped';
+    failureMessage?: string;
+    creationTime: string;
+    lastModifiedTime?: string;
+    endTime?: string;
+    baseModelArn: string;
+    hyperParameters?: Record<string, string>;
+    trainingDataConfig: {
+        s3Uri: string;
+    };
+    validationDataConfig?: {
+        validators: Array<{
+            s3Uri: string;
+        }>;
+    };
+    outputDataConfig: {
+        s3Uri: string;
+    };
+    customizationType?: 'FINE_TUNING' | 'CONTINUED_PRE_TRAINING';
+    outputModelKmsKeyArn?: string;
+    trainingMetrics?: {
+        trainingLoss?: number;
+    };
+    validationMetrics?: Array<{
+        validationLoss?: number;
+    }>;
+    vpcConfig?: {
+        subnetIds: string[];
+        securityGroupIds: string[];
+    };
+}
+export interface ListModelCustomizationJobsCommandInput {
+    creationTimeAfter?: string;
+    creationTimeBefore?: string;
+    statusEquals?: 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped';
+    nameContains?: string;
+    maxResults?: number;
+    nextToken?: string;
+    sortBy?: 'CreationTime';
+    sortOrder?: 'Ascending' | 'Descending';
+}
+export interface ListModelCustomizationJobsCommandOutput {
+    nextToken?: string;
+    modelCustomizationJobSummaries?: Array<{
+        jobArn: string;
+        jobName: string;
+        status: 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped';
+        lastModifiedTime?: string;
+        creationTime: string;
+        endTime?: string;
+        baseModelArn: string;
+        customModelArn?: string;
+        customModelName?: string;
+        customizationType?: 'FINE_TUNING' | 'CONTINUED_PRE_TRAINING';
+    }>;
+}
+export interface StopModelCustomizationJobCommandInput {
+    jobIdentifier: string;
+}
+export interface StopModelCustomizationJobCommandOutput {
+}
+export interface ListFoundationModelsCommandInput {
+    byProvider?: string;
+    byCustomizationType?: 'FINE_TUNING' | 'CONTINUED_PRE_TRAINING';
+    byOutputModality?: 'TEXT' | 'IMAGE' | 'EMBEDDING';
+    byInferenceType?: 'ON_DEMAND' | 'PROVISIONED';
+}
+export interface ListFoundationModelsCommandOutput {
+    modelSummaries?: FoundationModelSummary[];
+}
+export interface FoundationModelSummary {
+    modelArn: string;
+    modelId: string;
+    modelName: string;
+    providerName: string;
+    inputModalities: string[];
+    outputModalities: string[];
+    responseStreamingSupported: boolean;
+    customizationsSupported?: string[];
+    inferenceTypesSupported?: string[];
+    modelLifecycle?: {
+        status: 'ACTIVE' | 'LEGACY';
+    };
+}
+export interface GetFoundationModelCommandInput {
+    modelIdentifier: string;
+}
+export interface GetFoundationModelCommandOutput {
+    modelDetails: {
+        modelArn: string;
+        modelId: string;
+        modelName: string;
+        providerName: string;
+        inputModalities: string[];
+        outputModalities: string[];
+        responseStreamingSupported?: boolean;
+        customizationsSupported?: string[];
+        inferenceTypesSupported?: string[];
+        modelLifecycle?: {
+            status: 'ACTIVE' | 'LEGACY';
+        };
+    };
+}
+export interface ListCustomModelsCommandInput {
+    creationTimeBefore?: string;
+    creationTimeAfter?: string;
+    nameContains?: string;
+    baseModelArnEquals?: string;
+    foundationModelArnEquals?: string;
+    maxResults?: number;
+    nextToken?: string;
+    sortBy?: 'CreationTime';
+    sortOrder?: 'Ascending' | 'Descending';
+}
+export interface ListCustomModelsCommandOutput {
+    nextToken?: string;
+    modelSummaries?: Array<{
+        modelArn: string;
+        modelName: string;
+        creationTime: string;
+        baseModelArn: string;
+        baseModelName: string;
+        customizationType?: 'FINE_TUNING' | 'CONTINUED_PRE_TRAINING';
+    }>;
+}
+export interface DeleteCustomModelCommandInput {
+    modelIdentifier: string;
+}
+export interface DeleteCustomModelCommandOutput {
+}
+export interface GetCustomModelCommandInput {
+    modelIdentifier: string;
+}
+export interface GetCustomModelCommandOutput {
+    modelArn: string;
+    modelName: string;
+    jobName?: string;
+    jobArn?: string;
+    baseModelArn: string;
+    customizationType?: 'FINE_TUNING' | 'CONTINUED_PRE_TRAINING';
+    modelKmsKeyArn?: string;
+    hyperParameters?: Record<string, string>;
+    trainingDataConfig?: {
+        s3Uri: string;
+    };
+    validationDataConfig?: {
+        validators: Array<{
+            s3Uri: string;
+        }>;
+    };
+    outputDataConfig?: {
+        s3Uri: string;
+    };
+    trainingMetrics?: {
+        trainingLoss?: number;
+    };
+    validationMetrics?: Array<{
+        validationLoss?: number;
+    }>;
+    creationTime: string;
+}
+export interface CreateFoundationModelEntitlementCommandInput {
+    modelId: string;
+}
+export interface CreateFoundationModelEntitlementCommandOutput {
+    status: 'PENDING' | 'APPROVED' | 'DENIED';
+    modelId: string;
+}
+export interface ListModelInvocationJobsCommandInput {
+    submitTimeAfter?: string;
+    submitTimeBefore?: string;
+    statusEquals?: 'Submitted' | 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped' | 'PartiallyCompleted' | 'Expired' | 'Validating' | 'Scheduled';
+    nameContains?: string;
+    maxResults?: number;
+    nextToken?: string;
+    sortBy?: 'CreationTime';
+    sortOrder?: 'Ascending' | 'Descending';
+}
+export interface ListModelInvocationJobsCommandOutput {
+    nextToken?: string;
+    invocationJobSummaries?: Array<{
+        jobArn: string;
+        jobName: string;
+        modelId: string;
+        clientRequestToken?: string;
+        roleArn: string;
+        status: string;
+        message?: string;
+        submitTime: string;
+        lastModifiedTime?: string;
+        endTime?: string;
+        inputDataConfig: {
+            s3InputDataConfig: {
+                s3Uri: string;
+                s3InputFormat?: string;
+            };
+        };
+        outputDataConfig: {
+            s3OutputDataConfig: {
+                s3Uri: string;
+                s3EncryptionKeyId?: string;
+            };
+        };
+        timeoutDurationInHours?: number;
+        jobExpirationTime?: string;
+    }>;
+}
+export interface CreateGuardrailCommandInput {
+    name: string;
+    description?: string;
+    topicPolicyConfig?: {
+        topicsConfig: Array<{
+            name: string;
+            definition: string;
+            examples?: string[];
+            type: 'DENY';
+        }>;
+    };
+    contentPolicyConfig?: {
+        filtersConfig: Array<{
+            type: 'SEXUAL' | 'VIOLENCE' | 'HATE' | 'INSULTS' | 'MISCONDUCT' | 'PROMPT_ATTACK';
+            inputStrength: 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH';
+            outputStrength: 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH';
+        }>;
+    };
+    wordPolicyConfig?: {
+        wordsConfig?: Array<{
+            text: string;
+        }>;
+        managedWordListsConfig?: Array<{
+            type: 'PROFANITY';
+        }>;
+    };
+    sensitiveInformationPolicyConfig?: {
+        piiEntitiesConfig?: Array<{
+            type: string;
+            action: 'BLOCK' | 'ANONYMIZE';
+        }>;
+        regexesConfig?: Array<{
+            name: string;
+            description?: string;
+            pattern: string;
+            action: 'BLOCK' | 'ANONYMIZE';
+        }>;
+    };
+    contextualGroundingPolicyConfig?: {
+        filtersConfig: Array<{
+            type: 'GROUNDING' | 'RELEVANCE';
+            threshold: number;
+        }>;
+    };
+    blockedInputMessaging: string;
+    blockedOutputsMessaging: string;
+    kmsKeyId?: string;
+    tags?: Array<{
+        key: string;
+        value: string;
+    }>;
+    clientRequestToken?: string;
+}
+export interface CreateGuardrailCommandOutput {
+    guardrailId: string;
+    guardrailArn: string;
+    version: string;
+    createdAt: string;
+}
+export interface GetGuardrailCommandInput {
+    guardrailIdentifier: string;
+    guardrailVersion?: string;
+}
+export interface GetGuardrailCommandOutput {
+    name: string;
+    description?: string;
+    guardrailId: string;
+    guardrailArn: string;
+    version: string;
+    status: 'CREATING' | 'UPDATING' | 'VERSIONING' | 'READY' | 'FAILED' | 'DELETING';
+    topicPolicy?: {
+        topics: Array<{
+            name: string;
+            definition: string;
+            examples?: string[];
+            type: 'DENY';
+        }>;
+    };
+    contentPolicy?: {
+        filters: Array<{
+            type: string;
+            inputStrength: string;
+            outputStrength: string;
+        }>;
+    };
+    wordPolicy?: {
+        words?: Array<{
+            text: string;
+        }>;
+        managedWordLists?: Array<{
+            type: string;
+        }>;
+    };
+    sensitiveInformationPolicy?: {
+        piiEntities?: Array<{
+            type: string;
+            action: string;
+        }>;
+        regexes?: Array<{
+            name: string;
+            description?: string;
+            pattern: string;
+            action: string;
+        }>;
+    };
+    contextualGroundingPolicy?: {
+        filters: Array<{
+            type: string;
+            threshold: number;
+        }>;
+    };
+    createdAt: string;
+    updatedAt: string;
+    statusReasons?: string[];
+    failureRecommendations?: string[];
+    blockedInputMessaging: string;
+    blockedOutputsMessaging: string;
+    kmsKeyArn?: string;
+}
+export interface ListGuardrailsCommandInput {
+    guardrailIdentifier?: string;
+    maxResults?: number;
+    nextToken?: string;
+}
+export interface ListGuardrailsCommandOutput {
+    guardrails: Array<{
+        id: string;
+        arn: string;
+        status: string;
+        name: string;
+        description?: string;
+        version: string;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    nextToken?: string;
+}
+export interface DeleteGuardrailCommandInput {
+    guardrailIdentifier: string;
+    guardrailVersion?: string;
+}
+export interface DeleteGuardrailCommandOutput {
+}
+export interface CreateKnowledgeBaseCommandInput {
+    clientToken?: string;
+    name: string;
+    description?: string;
+    roleArn: string;
+    knowledgeBaseConfiguration: {
+        type: 'VECTOR';
+        vectorKnowledgeBaseConfiguration?: {
+            embeddingModelArn: string;
+            embeddingModelConfiguration?: {
+                bedrockEmbeddingModelConfiguration?: {
+                    dimensions?: number;
+                };
+            };
+        };
+    };
+    storageConfiguration: {
+        type: 'OPENSEARCH_SERVERLESS' | 'PINECONE' | 'REDIS_ENTERPRISE_CLOUD' | 'RDS' | 'MONGO_DB_ATLAS';
+        opensearchServerlessConfiguration?: {
+            collectionArn: string;
+            vectorIndexName: string;
+            fieldMapping: {
+                vectorField: string;
+                textField: string;
+                metadataField: string;
+            };
+        };
+        pineconeConfiguration?: {
+            connectionString: string;
+            credentialsSecretArn: string;
+            namespace?: string;
+            fieldMapping: {
+                textField: string;
+                metadataField: string;
+            };
+        };
+        redisEnterpriseCloudConfiguration?: {
+            endpoint: string;
+            vectorIndexName: string;
+            credentialsSecretArn: string;
+            fieldMapping: {
+                vectorField: string;
+                textField: string;
+                metadataField: string;
+            };
+        };
+        rdsConfiguration?: {
+            resourceArn: string;
+            credentialsSecretArn: string;
+            databaseName: string;
+            tableName: string;
+            fieldMapping: {
+                primaryKeyField: string;
+                vectorField: string;
+                textField: string;
+                metadataField: string;
+            };
+        };
+        mongoDbAtlasConfiguration?: {
+            endpoint: string;
+            databaseName: string;
+            collectionName: string;
+            vectorIndexName: string;
+            credentialsSecretArn: string;
+            fieldMapping: {
+                vectorField: string;
+                textField: string;
+                metadataField: string;
+            };
+        };
+    };
+    tags?: Record<string, string>;
+}
+export interface CreateKnowledgeBaseCommandOutput {
+    knowledgeBase: {
+        knowledgeBaseId: string;
+        name: string;
+        knowledgeBaseArn: string;
+        description?: string;
+        roleArn: string;
+        knowledgeBaseConfiguration: {
+            type: string;
+            vectorKnowledgeBaseConfiguration?: {
+                embeddingModelArn: string;
+            };
+        };
+        storageConfiguration: {
+            type: string;
+        };
+        status: 'CREATING' | 'ACTIVE' | 'DELETING' | 'UPDATING' | 'FAILED' | 'DELETE_UNSUCCESSFUL';
+        createdAt: string;
+        updatedAt: string;
+        failureReasons?: string[];
+    };
+}
+export interface CreateAgentCommandInput {
+    agentName: string;
+    clientToken?: string;
+    instruction?: string;
+    foundationModel?: string;
+    description?: string;
+    idleSessionTTLInSeconds?: number;
+    agentResourceRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    tags?: Record<string, string>;
+    promptOverrideConfiguration?: {
+        promptConfigurations: Array<{
+            promptType: 'PRE_PROCESSING' | 'ORCHESTRATION' | 'POST_PROCESSING' | 'KNOWLEDGE_BASE_RESPONSE_GENERATION';
+            promptCreationMode: 'DEFAULT' | 'OVERRIDDEN';
+            promptState?: 'ENABLED' | 'DISABLED';
+            basePromptTemplate?: string;
+            inferenceConfiguration?: {
+                temperature?: number;
+                topP?: number;
+                topK?: number;
+                maximumLength?: number;
+                stopSequences?: string[];
+            };
+            parserMode?: 'DEFAULT' | 'OVERRIDDEN';
+        }>;
+        overrideLambda?: string;
+    };
+    guardrailConfiguration?: {
+        guardrailIdentifier?: string;
+        guardrailVersion?: string;
+    };
+}
+export interface CreateAgentCommandOutput {
+    agent: {
+        agentId: string;
+        agentName: string;
+        agentArn: string;
+        agentVersion: string;
+        clientToken?: string;
+        instruction?: string;
+        agentStatus: 'CREATING' | 'PREPARING' | 'PREPARED' | 'NOT_PREPARED' | 'DELETING' | 'FAILED' | 'VERSIONING' | 'UPDATING';
+        foundationModel?: string;
+        description?: string;
+        idleSessionTTLInSeconds: number;
+        agentResourceRoleArn: string;
+        customerEncryptionKeyArn?: string;
+        createdAt: string;
+        updatedAt: string;
+        preparedAt?: string;
+        failureReasons?: string[];
+        recommendedActions?: string[];
+        promptOverrideConfiguration?: {
+            promptConfigurations: Array<{
+                promptType: string;
+                promptCreationMode: string;
+                promptState?: string;
+                basePromptTemplate?: string;
+                inferenceConfiguration?: {
+                    temperature?: number;
+                    topP?: number;
+                    topK?: number;
+                    maximumLength?: number;
+                    stopSequences?: string[];
+                };
+                parserMode?: string;
+            }>;
+            overrideLambda?: string;
+        };
+        guardrailConfiguration?: {
+            guardrailIdentifier?: string;
+            guardrailVersion?: string;
+        };
+    };
+}
+export interface InvokeAgentCommandInput {
+    agentId: string;
+    agentAliasId: string;
+    sessionId: string;
+    endSession?: boolean;
+    enableTrace?: boolean;
+    inputText?: string;
+    memoryId?: string;
+    sessionState?: {
+        sessionAttributes?: Record<string, string>;
+        promptSessionAttributes?: Record<string, string>;
+        returnControlInvocationResults?: Array<{
+            functionResult?: {
+                actionGroup: string;
+                function: string;
+                responseBody?: Record<string, {
+                    body: string;
+                }>;
+            };
+        }>;
+        invocationId?: string;
+        files?: Array<{
+            name: string;
+            source: {
+                sourceType: 'S3' | 'BYTE_CONTENT';
+                s3Location?: {
+                    uri: string;
+                };
+                byteContent?: {
+                    mediaType: string;
+                    data: Uint8Array;
+                };
+            };
+            useCase: 'CODE_INTERPRETER' | 'CHAT';
+        }>;
+        knowledgeBaseConfigurations?: Array<{
+            knowledgeBaseId: string;
+            retrievalConfiguration: {
+                vectorSearchConfiguration: {
+                    numberOfResults?: number;
+                    overrideSearchType?: 'HYBRID' | 'SEMANTIC';
+                    filter?: Record<string, unknown>;
+                };
+            };
+        }>;
+    };
+}
+export interface InvokeAgentCommandOutput {
+    completion: AsyncIterable<{
+        chunk?: {
+            bytes: Uint8Array;
+            attribution?: {
+                citations: Array<{
+                    generatedResponsePart?: {
+                        textResponsePart?: {
+                            text: string;
+                            span?: {
+                                start: number;
+                                end: number;
+                            };
+                        };
+                    };
+                    retrievedReferences?: Array<{
+                        content?: {
+                            text: string;
+                        };
+                        location?: {
+                            type: string;
+                            s3Location?: {
+                                uri: string;
+                            };
+                        };
+                        metadata?: Record<string, unknown>;
+                    }>;
+                }>;
+            };
+        };
+        trace?: {
+            agentId?: string;
+            agentAliasId?: string;
+            sessionId?: string;
+            agentVersion?: string;
+            trace?: Record<string, unknown>;
+        };
+        returnControl?: {
+            invocationId: string;
+            invocationInputs: Array<{
+                functionInvocationInput?: {
+                    actionGroup: string;
+                    function: string;
+                    parameters: Array<{
+                        name: string;
+                        type: string;
+                        value: string;
+                    }>;
+                };
+            }>;
+        };
+        files?: {
+            files: Array<{
+                name: string;
+                type: string;
+                bytes: Uint8Array;
+            }>;
+        };
+    }>;
+    contentType: string;
+    sessionId: string;
+    memoryId?: string;
+}
+/**
+ * Bedrock Runtime client for AI model invocations
+ */
+export declare class BedrockRuntimeClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Invoke a Bedrock model (matches AWS SDK InvokeModelCommand)
+     */
+    invokeModel(params: InvokeModelCommandInput): Promise<InvokeModelCommandOutput>;
+    /**
+     * Invoke model with streaming response (matches AWS SDK InvokeModelWithResponseStreamCommand)
+     */
+    invokeModelWithResponseStream(params: InvokeModelWithResponseStreamCommandInput): Promise<InvokeModelWithResponseStreamCommandOutput>;
+    /**
+     * Internal method to make streaming request
+     */
+    private makeStreamRequest;
+    /**
+     * Parse AWS event stream format
+     */
+    private parseEventStream;
+    /**
+     * Extract JSON chunks from event stream buffer
+     */
+    private extractJsonChunks;
+    /**
+     * Get credentials from environment
+     */
+    private getCredentialsFromEnv;
+    /**
+     * Sign request for streaming (simplified SigV4)
+     */
+    private signStreamRequest;
+    /**
+     * Invoke Claude model with messages API (convenience method)
+     */
+    invokeClaudeMessages(params: {
+        modelId?: string;
+        messages: BedrockMessage[];
+        maxTokens?: number;
+        temperature?: number;
+        topP?: number;
+        topK?: number;
+        stopSequences?: string[];
+        system?: string;
+        tools?: BedrockToolDefinition[];
+        toolChoice?: {
+            type: 'auto';
+        } | {
+            type: 'any';
+        } | {
+            type: 'tool';
+            name: string;
+        };
+    }): Promise<BedrockResponse>;
+    /**
+     * Converse API - unified conversation interface for all models
+     */
+    converse(params: ConverseCommandInput): Promise<ConverseCommandOutput>;
+    /**
+     * Generate embeddings using a Bedrock model
+     */
+    generateEmbeddings(params: {
+        modelId?: string;
+        inputText: string | string[];
+        dimensions?: number;
+        normalize?: boolean;
+    }): Promise<{
+        embedding?: number[];
+        embeddings?: number[][];
+    }>;
+    /**
+     * Apply guardrail to content
+     */
+    applyGuardrail(params: {
+        guardrailIdentifier: string;
+        guardrailVersion: string;
+        source: 'INPUT' | 'OUTPUT';
+        content: Array<{
+            text: {
+                text: string;
+            };
+        }>;
+    }): Promise<{
+        action: 'NONE' | 'GUARDRAIL_INTERVENED';
+        outputs: Array<{
+            text: string;
+        }>;
+        assessments: Array<{
+            topicPolicy?: {
+                topics: Array<{
+                    name: string;
+                    type: string;
+                    action: string;
+                }>;
+            };
+            contentPolicy?: {
+                filters: Array<{
+                    type: string;
+                    confidence: string;
+                    action: string;
+                }>;
+            };
+            wordPolicy?: {
+                customWords: Array<{
+                    match: string;
+                    action: string;
+                }>;
+                managedWordLists: Array<{
+                    match: string;
+                    type: string;
+                    action: string;
+                }>;
+            };
+            sensitiveInformationPolicy?: {
+                piiEntities: Array<{
+                    type: string;
+                    match: string;
+                    action: string;
+                }>;
+                regexes: Array<{
+                    name: string;
+                    match: string;
+                    action: string;
+                }>;
+            };
+        }>;
+    }>;
+}
+/**
+ * Bedrock client for model management (not runtime)
+ */
+export declare class BedrockClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * List available foundation models
+     */
+    listFoundationModels(params?: ListFoundationModelsCommandInput): Promise<ListFoundationModelsCommandOutput>;
+    /**
+     * Get details about a foundation model
+     */
+    getFoundationModel(params: GetFoundationModelCommandInput): Promise<GetFoundationModelCommandOutput>;
+    /**
+     * Create a model customization job (fine-tuning)
+     */
+    createModelCustomizationJob(params: CreateModelCustomizationJobCommandInput): Promise<CreateModelCustomizationJobCommandOutput>;
+    /**
+     * Get model customization job details
+     */
+    getModelCustomizationJob(params: GetModelCustomizationJobCommandInput): Promise<GetModelCustomizationJobCommandOutput>;
+    /**
+     * List model customization jobs
+     */
+    listModelCustomizationJobs(params?: ListModelCustomizationJobsCommandInput): Promise<ListModelCustomizationJobsCommandOutput>;
+    /**
+     * Stop a model customization job
+     */
+    stopModelCustomizationJob(params: StopModelCustomizationJobCommandInput): Promise<StopModelCustomizationJobCommandOutput>;
+    /**
+     * List custom models
+     */
+    listCustomModels(params?: ListCustomModelsCommandInput): Promise<ListCustomModelsCommandOutput>;
+    /**
+     * Get custom model details
+     */
+    getCustomModel(params: GetCustomModelCommandInput): Promise<GetCustomModelCommandOutput>;
+    /**
+     * Delete a custom model
+     */
+    deleteCustomModel(params: DeleteCustomModelCommandInput): Promise<DeleteCustomModelCommandOutput>;
+    /**
+     * Request access to a foundation model
+     */
+    requestModelAccess(params: CreateFoundationModelEntitlementCommandInput): Promise<CreateFoundationModelEntitlementCommandOutput>;
+    /**
+     * Create a guardrail
+     */
+    createGuardrail(params: CreateGuardrailCommandInput): Promise<CreateGuardrailCommandOutput>;
+    /**
+     * Get guardrail details
+     */
+    getGuardrail(params: GetGuardrailCommandInput): Promise<GetGuardrailCommandOutput>;
+    /**
+     * List guardrails
+     */
+    listGuardrails(params?: ListGuardrailsCommandInput): Promise<ListGuardrailsCommandOutput>;
+    /**
+     * Delete a guardrail
+     */
+    deleteGuardrail(params: DeleteGuardrailCommandInput): Promise<DeleteGuardrailCommandOutput>;
+    /**
+     * List model invocation jobs (batch inference)
+     */
+    listModelInvocationJobs(params?: ListModelInvocationJobsCommandInput): Promise<ListModelInvocationJobsCommandOutput>;
+    /**
+     * Wait for a model customization job to complete
+     */
+    waitForModelCustomizationJob(jobIdentifier: string, options?: {
+        maxWaitMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<GetModelCustomizationJobCommandOutput>;
+    /**
+     * Request access to multiple models
+     */
+    requestAccessToModels(modelIds: string[]): Promise<Array<{
+        modelId: string;
+        status: string;
+        error?: string;
+    }>>;
+    /**
+     * List all foundation models from a specific provider
+     */
+    listModelsByProvider(provider: string): Promise<FoundationModelSummary[]>;
+    /**
+     * List all Claude models
+     */
+    listClaudeModels(): Promise<FoundationModelSummary[]>;
+    /**
+     * List all embedding models
+     */
+    listEmbeddingModels(): Promise<FoundationModelSummary[]>;
+    /**
+     * Create a batch inference job
+     */
+    createModelInvocationJob(params: CreateModelInvocationJobCommandInput): Promise<CreateModelInvocationJobCommandOutput>;
+    /**
+     * Get batch inference job details
+     */
+    getModelInvocationJob(params: GetModelInvocationJobCommandInput): Promise<GetModelInvocationJobCommandOutput>;
+    /**
+     * Stop a batch inference job
+     */
+    stopModelInvocationJob(params: StopModelInvocationJobCommandInput): Promise<StopModelInvocationJobCommandOutput>;
+    /**
+     * Create provisioned throughput for a model
+     */
+    createProvisionedModelThroughput(params: CreateProvisionedModelThroughputCommandInput): Promise<CreateProvisionedModelThroughputCommandOutput>;
+    /**
+     * Get provisioned throughput details
+     */
+    getProvisionedModelThroughput(params: GetProvisionedModelThroughputCommandInput): Promise<GetProvisionedModelThroughputCommandOutput>;
+    /**
+     * List provisioned throughputs
+     */
+    listProvisionedModelThroughputs(params?: ListProvisionedModelThroughputsCommandInput): Promise<ListProvisionedModelThroughputsCommandOutput>;
+    /**
+     * Update provisioned throughput
+     */
+    updateProvisionedModelThroughput(params: UpdateProvisionedModelThroughputCommandInput): Promise<UpdateProvisionedModelThroughputCommandOutput>;
+    /**
+     * Delete provisioned throughput
+     */
+    deleteProvisionedModelThroughput(params: DeleteProvisionedModelThroughputCommandInput): Promise<DeleteProvisionedModelThroughputCommandOutput>;
+    /**
+     * Create a model evaluation job
+     */
+    createEvaluationJob(params: CreateEvaluationJobCommandInput): Promise<CreateEvaluationJobCommandOutput>;
+    /**
+     * Get evaluation job details
+     */
+    getEvaluationJob(params: GetEvaluationJobCommandInput): Promise<GetEvaluationJobCommandOutput>;
+    /**
+     * List evaluation jobs
+     */
+    listEvaluationJobs(params?: ListEvaluationJobsCommandInput): Promise<ListEvaluationJobsCommandOutput>;
+    /**
+     * Stop an evaluation job
+     */
+    stopEvaluationJob(params: StopEvaluationJobCommandInput): Promise<StopEvaluationJobCommandOutput>;
+    /**
+     * Get inference profile details
+     */
+    getInferenceProfile(params: GetInferenceProfileCommandInput): Promise<GetInferenceProfileCommandOutput>;
+    /**
+     * List inference profiles
+     */
+    listInferenceProfiles(params?: ListInferenceProfilesCommandInput): Promise<ListInferenceProfilesCommandOutput>;
+    /**
+     * Create an inference profile
+     */
+    createInferenceProfile(params: CreateInferenceProfileCommandInput): Promise<CreateInferenceProfileCommandOutput>;
+    /**
+     * Delete an inference profile
+     */
+    deleteInferenceProfile(params: DeleteInferenceProfileCommandInput): Promise<DeleteInferenceProfileCommandOutput>;
+    /**
+     * Create a model copy job
+     */
+    createModelCopyJob(params: CreateModelCopyJobCommandInput): Promise<CreateModelCopyJobCommandOutput>;
+    /**
+     * Get model copy job details
+     */
+    getModelCopyJob(params: GetModelCopyJobCommandInput): Promise<GetModelCopyJobCommandOutput>;
+    /**
+     * List model copy jobs
+     */
+    listModelCopyJobs(params?: ListModelCopyJobsCommandInput): Promise<ListModelCopyJobsCommandOutput>;
+}
+/**
+ * Bedrock Agent Runtime client for invoking agents
+ */
+export declare class BedrockAgentRuntimeClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Invoke a Bedrock agent
+     */
+    invokeAgent(params: InvokeAgentCommandInput): Promise<{
+        completion: string;
+        sessionId: string;
+        memoryId?: string;
+        citations?: Array<{
+            generatedResponsePart?: {
+                textResponsePart?: {
+                    text: string;
+                };
+            };
+            retrievedReferences?: Array<{
+                content?: {
+                    text: string;
+                };
+                location?: {
+                    s3Location?: {
+                        uri: string;
+                    };
+                };
+            }>;
+        }>;
+    }>;
+    /**
+     * Retrieve from a knowledge base
+     */
+    retrieve(params: {
+        knowledgeBaseId: string;
+        retrievalQuery: {
+            text: string;
+        };
+        retrievalConfiguration?: {
+            vectorSearchConfiguration: {
+                numberOfResults?: number;
+                overrideSearchType?: 'HYBRID' | 'SEMANTIC';
+                filter?: Record<string, unknown>;
+            };
+        };
+        nextToken?: string;
+    }): Promise<{
+        retrievalResults: Array<{
+            content: {
+                text: string;
+            };
+            location?: {
+                type: string;
+                s3Location?: {
+                    uri: string;
+                };
+            };
+            score?: number;
+            metadata?: Record<string, unknown>;
+        }>;
+        nextToken?: string;
+    }>;
+    /**
+     * Retrieve and generate using a knowledge base
+     */
+    retrieveAndGenerate(params: {
+        input: {
+            text: string;
+        };
+        retrieveAndGenerateConfiguration: {
+            type: 'KNOWLEDGE_BASE';
+            knowledgeBaseConfiguration: {
+                knowledgeBaseId: string;
+                modelArn: string;
+                retrievalConfiguration?: {
+                    vectorSearchConfiguration: {
+                        numberOfResults?: number;
+                        overrideSearchType?: 'HYBRID' | 'SEMANTIC';
+                        filter?: Record<string, unknown>;
+                    };
+                };
+                generationConfiguration?: {
+                    promptTemplate?: {
+                        textPromptTemplate: string;
+                    };
+                    inferenceConfig?: {
+                        textInferenceConfig?: {
+                            temperature?: number;
+                            topP?: number;
+                            maxTokens?: number;
+                            stopSequences?: string[];
+                        };
+                    };
+                    guardrailConfiguration?: {
+                        guardrailId: string;
+                        guardrailVersion: string;
+                    };
+                };
+            };
+        };
+        sessionConfiguration?: {
+            kmsKeyArn?: string;
+        };
+        sessionId?: string;
+    }): Promise<{
+        sessionId: string;
+        output: {
+            text: string;
+        };
+        citations?: Array<{
+            generatedResponsePart?: {
+                textResponsePart?: {
+                    text: string;
+                    span?: {
+                        start: number;
+                        end: number;
+                    };
+                };
+            };
+            retrievedReferences?: Array<{
+                content: {
+                    text: string;
+                };
+                location?: {
+                    type: string;
+                    s3Location?: {
+                        uri: string;
+                    };
+                };
+                metadata?: Record<string, unknown>;
+            }>;
+        }>;
+        guardrailAction?: 'INTERVENED' | 'NONE';
+    }>;
+}
+/**
+ * Bedrock Agent client for agent management
+ */
+export declare class BedrockAgentClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Create an agent
+     */
+    createAgent(params: CreateAgentCommandInput): Promise<CreateAgentCommandOutput>;
+    /**
+     * Get agent details
+     */
+    getAgent(params: {
+        agentId: string;
+    }): Promise<{
+        agent: CreateAgentCommandOutput['agent'];
+    }>;
+    /**
+     * List agents
+     */
+    listAgents(params?: {
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        agentSummaries: Array<{
+            agentId: string;
+            agentName: string;
+            agentStatus: string;
+            description?: string;
+            updatedAt: string;
+            latestAgentVersion: string;
+        }>;
+        nextToken?: string;
+    }>;
+    /**
+     * Delete an agent
+     */
+    deleteAgent(params: {
+        agentId: string;
+        skipResourceInUseCheck?: boolean;
+    }): Promise<{
+        agentId: string;
+        agentStatus: string;
+    }>;
+    /**
+     * Prepare an agent for invocation
+     */
+    prepareAgent(params: {
+        agentId: string;
+    }): Promise<{
+        agentId: string;
+        agentStatus: string;
+        agentVersion: string;
+        preparedAt: string;
+    }>;
+    /**
+     * Create a knowledge base
+     */
+    createKnowledgeBase(params: CreateKnowledgeBaseCommandInput): Promise<CreateKnowledgeBaseCommandOutput>;
+    /**
+     * Get knowledge base details
+     */
+    getKnowledgeBase(params: {
+        knowledgeBaseId: string;
+    }): Promise<{
+        knowledgeBase: CreateKnowledgeBaseCommandOutput['knowledgeBase'];
+    }>;
+    /**
+     * List knowledge bases
+     */
+    listKnowledgeBases(params?: {
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        knowledgeBaseSummaries: Array<{
+            knowledgeBaseId: string;
+            name: string;
+            description?: string;
+            status: string;
+            updatedAt: string;
+        }>;
+        nextToken?: string;
+    }>;
+    /**
+     * Delete a knowledge base
+     */
+    deleteKnowledgeBase(params: {
+        knowledgeBaseId: string;
+    }): Promise<{
+        knowledgeBaseId: string;
+        status: string;
+    }>;
+    /**
+     * Create a data source for a knowledge base
+     */
+    createDataSource(params: CreateDataSourceCommandInput): Promise<CreateDataSourceCommandOutput>;
+    /**
+     * Get data source details
+     */
+    getDataSource(params: GetDataSourceCommandInput): Promise<GetDataSourceCommandOutput>;
+    /**
+     * List data sources for a knowledge base
+     */
+    listDataSources(params: ListDataSourcesCommandInput): Promise<ListDataSourcesCommandOutput>;
+    /**
+     * Update a data source
+     */
+    updateDataSource(params: UpdateDataSourceCommandInput): Promise<UpdateDataSourceCommandOutput>;
+    /**
+     * Delete a data source
+     */
+    deleteDataSource(params: DeleteDataSourceCommandInput): Promise<DeleteDataSourceCommandOutput>;
+    /**
+     * Start an ingestion job to sync data source with knowledge base
+     */
+    startIngestionJob(params: StartIngestionJobCommandInput): Promise<StartIngestionJobCommandOutput>;
+    /**
+     * Get ingestion job details
+     */
+    getIngestionJob(params: GetIngestionJobCommandInput): Promise<GetIngestionJobCommandOutput>;
+    /**
+     * List ingestion jobs
+     */
+    listIngestionJobs(params: ListIngestionJobsCommandInput): Promise<ListIngestionJobsCommandOutput>;
+    /**
+     * Create a prompt
+     */
+    createPrompt(params: CreatePromptCommandInput): Promise<CreatePromptCommandOutput>;
+    /**
+     * Get prompt details
+     */
+    getPrompt(params: GetPromptCommandInput): Promise<GetPromptCommandOutput>;
+    /**
+     * List prompts
+     */
+    listPrompts(params?: ListPromptsCommandInput): Promise<ListPromptsCommandOutput>;
+    /**
+     * Delete a prompt
+     */
+    deletePrompt(params: DeletePromptCommandInput): Promise<DeletePromptCommandOutput>;
+    /**
+     * Create a new version of a prompt
+     */
+    createPromptVersion(params: CreatePromptVersionCommandInput): Promise<CreatePromptVersionCommandOutput>;
+    /**
+     * Create a flow
+     */
+    createFlow(params: CreateFlowCommandInput): Promise<CreateFlowCommandOutput>;
+    /**
+     * Get flow details
+     */
+    getFlow(params: GetFlowCommandInput): Promise<GetFlowCommandOutput>;
+    /**
+     * List flows
+     */
+    listFlows(params?: ListFlowsCommandInput): Promise<ListFlowsCommandOutput>;
+    /**
+     * Update a flow
+     */
+    updateFlow(params: UpdateFlowCommandInput): Promise<UpdateFlowCommandOutput>;
+    /**
+     * Delete a flow
+     */
+    deleteFlow(params: DeleteFlowCommandInput): Promise<DeleteFlowCommandOutput>;
+    /**
+     * Prepare a flow for execution
+     */
+    prepareFlow(params: PrepareFlowCommandInput): Promise<PrepareFlowCommandOutput>;
+    /**
+     * Create a new version of a flow
+     */
+    createFlowVersion(params: CreateFlowVersionCommandInput): Promise<CreateFlowVersionCommandOutput>;
+    /**
+     * Create a flow alias
+     */
+    createFlowAlias(params: CreateFlowAliasCommandInput): Promise<CreateFlowAliasCommandOutput>;
+}
+export interface CreateModelInvocationJobCommandInput {
+    jobName: string;
+    modelId: string;
+    roleArn: string;
+    inputDataConfig: {
+        s3InputDataConfig: {
+            s3Uri: string;
+            s3InputFormat?: 'JSONL';
+        };
+    };
+    outputDataConfig: {
+        s3OutputDataConfig: {
+            s3Uri: string;
+            s3EncryptionKeyId?: string;
+        };
+    };
+    clientRequestToken?: string;
+    timeoutDurationInHours?: number;
+    tags?: Array<{
+        key: string;
+        value: string;
+    }>;
+    vpcConfig?: {
+        subnetIds: string[];
+        securityGroupIds: string[];
+    };
+}
+export interface CreateModelInvocationJobCommandOutput {
+    jobArn: string;
+}
+export interface GetModelInvocationJobCommandInput {
+    jobIdentifier: string;
+}
+export interface GetModelInvocationJobCommandOutput {
+    jobArn: string;
+    jobName: string;
+    modelId: string;
+    clientRequestToken?: string;
+    roleArn: string;
+    status: 'Submitted' | 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped' | 'PartiallyCompleted' | 'Expired' | 'Validating' | 'Scheduled';
+    message?: string;
+    submitTime: string;
+    lastModifiedTime?: string;
+    endTime?: string;
+    inputDataConfig: {
+        s3InputDataConfig: {
+            s3Uri: string;
+            s3InputFormat?: string;
+        };
+    };
+    outputDataConfig: {
+        s3OutputDataConfig: {
+            s3Uri: string;
+            s3EncryptionKeyId?: string;
+        };
+    };
+    vpcConfig?: {
+        subnetIds: string[];
+        securityGroupIds: string[];
+    };
+    timeoutDurationInHours?: number;
+    jobExpirationTime?: string;
+}
+export interface StopModelInvocationJobCommandInput {
+    jobIdentifier: string;
+}
+export interface StopModelInvocationJobCommandOutput {
+}
+export interface CreateProvisionedModelThroughputCommandInput {
+    modelUnits: number;
+    provisionedModelName: string;
+    modelId: string;
+    clientRequestToken?: string;
+    commitmentDuration?: 'ONE_MONTH' | 'SIX_MONTHS';
+    tags?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+export interface CreateProvisionedModelThroughputCommandOutput {
+    provisionedModelArn: string;
+}
+export interface GetProvisionedModelThroughputCommandInput {
+    provisionedModelId: string;
+}
+export interface GetProvisionedModelThroughputCommandOutput {
+    modelUnits: number;
+    desiredModelUnits: number;
+    provisionedModelName: string;
+    provisionedModelArn: string;
+    modelArn: string;
+    desiredModelArn: string;
+    foundationModelArn: string;
+    status: 'Creating' | 'InService' | 'Updating' | 'Failed';
+    creationTime: string;
+    lastModifiedTime: string;
+    failureMessage?: string;
+    commitmentDuration?: 'ONE_MONTH' | 'SIX_MONTHS';
+    commitmentExpirationTime?: string;
+}
+export interface ListProvisionedModelThroughputsCommandInput {
+    creationTimeAfter?: string;
+    creationTimeBefore?: string;
+    statusEquals?: 'Creating' | 'InService' | 'Updating' | 'Failed';
+    modelArnEquals?: string;
+    nameContains?: string;
+    maxResults?: number;
+    nextToken?: string;
+    sortBy?: 'CreationTime';
+    sortOrder?: 'Ascending' | 'Descending';
+}
+export interface ListProvisionedModelThroughputsCommandOutput {
+    nextToken?: string;
+    provisionedModelSummaries?: Array<{
+        provisionedModelName: string;
+        provisionedModelArn: string;
+        modelArn: string;
+        desiredModelArn: string;
+        foundationModelArn: string;
+        modelUnits: number;
+        desiredModelUnits: number;
+        status: 'Creating' | 'InService' | 'Updating' | 'Failed';
+        commitmentDuration?: 'ONE_MONTH' | 'SIX_MONTHS';
+        commitmentExpirationTime?: string;
+        creationTime: string;
+        lastModifiedTime: string;
+    }>;
+}
+export interface UpdateProvisionedModelThroughputCommandInput {
+    provisionedModelId: string;
+    desiredProvisionedModelName?: string;
+    desiredModelId?: string;
+}
+export interface UpdateProvisionedModelThroughputCommandOutput {
+}
+export interface DeleteProvisionedModelThroughputCommandInput {
+    provisionedModelId: string;
+}
+export interface DeleteProvisionedModelThroughputCommandOutput {
+}
+export interface CreateEvaluationJobCommandInput {
+    jobName: string;
+    jobDescription?: string;
+    clientRequestToken?: string;
+    roleArn: string;
+    customerEncryptionKeyId?: string;
+    jobTags?: Array<{
+        key: string;
+        value: string;
+    }>;
+    evaluationConfig: {
+        automated?: {
+            datasetMetricConfigs: Array<{
+                taskType: 'Summarization' | 'Classification' | 'QuestionAndAnswer' | 'Generation' | 'Custom';
+                dataset: {
+                    name: string;
+                    datasetLocation?: {
+                        s3Uri: string;
+                    };
+                };
+                metricNames: string[];
+            }>;
+        };
+        human?: {
+            humanWorkflowConfig: {
+                flowDefinitionArn: string;
+                instructions?: string;
+            };
+            customMetrics?: Array<{
+                name: string;
+                description?: string;
+                ratingMethod: 'ThumbsUpDown' | 'IndividualLikertScale' | 'ComparisonLikertScale' | 'ComparisonChoice' | 'ComparisonRank' | 'FreeformFeedback';
+            }>;
+            datasetMetricConfigs: Array<{
+                taskType: 'Summarization' | 'Classification' | 'QuestionAndAnswer' | 'Generation' | 'Custom';
+                dataset: {
+                    name: string;
+                    datasetLocation?: {
+                        s3Uri: string;
+                    };
+                };
+                metricNames: string[];
+            }>;
+        };
+    };
+    inferenceConfig: {
+        models: Array<{
+            bedrockModel?: {
+                modelIdentifier: string;
+                inferenceParams: string;
+            };
+        }>;
+    };
+    outputDataConfig: {
+        s3Uri: string;
+    };
+}
+export interface CreateEvaluationJobCommandOutput {
+    jobArn: string;
+}
+export interface GetEvaluationJobCommandInput {
+    jobIdentifier: string;
+}
+export interface GetEvaluationJobCommandOutput {
+    jobName: string;
+    status: 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped';
+    jobArn: string;
+    jobDescription?: string;
+    roleArn: string;
+    customerEncryptionKeyId?: string;
+    jobType: 'Human' | 'Automated';
+    evaluationConfig: {
+        automated?: {
+            datasetMetricConfigs: Array<{
+                taskType: string;
+                dataset: {
+                    name: string;
+                    datasetLocation?: {
+                        s3Uri: string;
+                    };
+                };
+                metricNames: string[];
+            }>;
+        };
+        human?: {
+            humanWorkflowConfig: {
+                flowDefinitionArn: string;
+                instructions?: string;
+            };
+            customMetrics?: Array<{
+                name: string;
+                description?: string;
+                ratingMethod: string;
+            }>;
+            datasetMetricConfigs: Array<{
+                taskType: string;
+                dataset: {
+                    name: string;
+                    datasetLocation?: {
+                        s3Uri: string;
+                    };
+                };
+                metricNames: string[];
+            }>;
+        };
+    };
+    inferenceConfig: {
+        models: Array<{
+            bedrockModel?: {
+                modelIdentifier: string;
+                inferenceParams: string;
+            };
+        }>;
+    };
+    outputDataConfig: {
+        s3Uri: string;
+    };
+    creationTime: string;
+    lastModifiedTime?: string;
+    failureMessages?: string[];
+}
+export interface ListEvaluationJobsCommandInput {
+    creationTimeAfter?: string;
+    creationTimeBefore?: string;
+    statusEquals?: 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped';
+    nameContains?: string;
+    maxResults?: number;
+    nextToken?: string;
+    sortBy?: 'CreationTime';
+    sortOrder?: 'Ascending' | 'Descending';
+}
+export interface ListEvaluationJobsCommandOutput {
+    nextToken?: string;
+    jobSummaries?: Array<{
+        jobArn: string;
+        jobName: string;
+        status: 'InProgress' | 'Completed' | 'Failed' | 'Stopping' | 'Stopped';
+        creationTime: string;
+        jobType: 'Human' | 'Automated';
+        evaluationTaskTypes: string[];
+        modelIdentifiers: string[];
+    }>;
+}
+export interface StopEvaluationJobCommandInput {
+    jobIdentifier: string;
+}
+export interface StopEvaluationJobCommandOutput {
+}
+export interface GetInferenceProfileCommandInput {
+    inferenceProfileIdentifier: string;
+}
+export interface GetInferenceProfileCommandOutput {
+    inferenceProfileName: string;
+    inferenceProfileArn: string;
+    inferenceProfileId: string;
+    description?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    models: Array<{
+        modelArn: string;
+    }>;
+    status: 'ACTIVE';
+    type: 'SYSTEM_DEFINED' | 'APPLICATION';
+}
+export interface ListInferenceProfilesCommandInput {
+    maxResults?: number;
+    nextToken?: string;
+    typeEquals?: 'SYSTEM_DEFINED' | 'APPLICATION';
+}
+export interface ListInferenceProfilesCommandOutput {
+    inferenceProfileSummaries?: Array<{
+        inferenceProfileName: string;
+        inferenceProfileArn: string;
+        inferenceProfileId: string;
+        description?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        models: Array<{
+            modelArn: string;
+        }>;
+        status: 'ACTIVE';
+        type: 'SYSTEM_DEFINED' | 'APPLICATION';
+    }>;
+    nextToken?: string;
+}
+export interface CreateInferenceProfileCommandInput {
+    inferenceProfileName: string;
+    description?: string;
+    clientRequestToken?: string;
+    modelSource: {
+        copyFrom: string;
+    };
+    tags?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+export interface CreateInferenceProfileCommandOutput {
+    inferenceProfileArn: string;
+    status?: 'ACTIVE';
+}
+export interface DeleteInferenceProfileCommandInput {
+    inferenceProfileIdentifier: string;
+}
+export interface DeleteInferenceProfileCommandOutput {
+}
+export interface CreatePromptCommandInput {
+    name: string;
+    description?: string;
+    customerEncryptionKeyArn?: string;
+    defaultVariant?: string;
+    variants?: Array<{
+        name: string;
+        modelId?: string;
+        templateType: 'TEXT';
+        templateConfiguration: {
+            text: {
+                text: string;
+                inputVariables?: Array<{
+                    name: string;
+                }>;
+            };
+        };
+        inferenceConfiguration?: {
+            text?: {
+                temperature?: number;
+                topP?: number;
+                maxTokens?: number;
+                stopSequences?: string[];
+            };
+        };
+    }>;
+    clientToken?: string;
+    tags?: Record<string, string>;
+}
+export interface CreatePromptCommandOutput {
+    name: string;
+    description?: string;
+    customerEncryptionKeyArn?: string;
+    defaultVariant?: string;
+    variants?: Array<{
+        name: string;
+        modelId?: string;
+        templateType: string;
+        templateConfiguration: {
+            text?: {
+                text: string;
+                inputVariables?: Array<{
+                    name: string;
+                }>;
+            };
+        };
+        inferenceConfiguration?: {
+            text?: {
+                temperature?: number;
+                topP?: number;
+                maxTokens?: number;
+                stopSequences?: string[];
+            };
+        };
+    }>;
+    id: string;
+    arn: string;
+    version: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface GetPromptCommandInput {
+    promptIdentifier: string;
+    promptVersion?: string;
+}
+export interface GetPromptCommandOutput {
+    name: string;
+    description?: string;
+    customerEncryptionKeyArn?: string;
+    defaultVariant?: string;
+    variants?: Array<{
+        name: string;
+        modelId?: string;
+        templateType: string;
+        templateConfiguration: {
+            text?: {
+                text: string;
+                inputVariables?: Array<{
+                    name: string;
+                }>;
+            };
+        };
+        inferenceConfiguration?: {
+            text?: {
+                temperature?: number;
+                topP?: number;
+                maxTokens?: number;
+                stopSequences?: string[];
+            };
+        };
+    }>;
+    id: string;
+    arn: string;
+    version: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ListPromptsCommandInput {
+    promptIdentifier?: string;
+    maxResults?: number;
+    nextToken?: string;
+}
+export interface ListPromptsCommandOutput {
+    promptSummaries: Array<{
+        name: string;
+        description?: string;
+        id: string;
+        arn: string;
+        version: string;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    nextToken?: string;
+}
+export interface DeletePromptCommandInput {
+    promptIdentifier: string;
+    promptVersion?: string;
+}
+export interface DeletePromptCommandOutput {
+    id: string;
+    version?: string;
+}
+export interface CreatePromptVersionCommandInput {
+    promptIdentifier: string;
+    description?: string;
+    clientToken?: string;
+    tags?: Record<string, string>;
+}
+export interface CreatePromptVersionCommandOutput {
+    name: string;
+    description?: string;
+    customerEncryptionKeyArn?: string;
+    defaultVariant?: string;
+    variants?: Array<{
+        name: string;
+        modelId?: string;
+        templateType: string;
+        templateConfiguration: {
+            text?: {
+                text: string;
+                inputVariables?: Array<{
+                    name: string;
+                }>;
+            };
+        };
+        inferenceConfiguration?: {
+            text?: {
+                temperature?: number;
+                topP?: number;
+                maxTokens?: number;
+                stopSequences?: string[];
+            };
+        };
+    }>;
+    id: string;
+    arn: string;
+    version: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface FlowNodeConfiguration {
+    input?: Record<string, never>;
+    output?: Record<string, never>;
+    knowledgeBase?: {
+        knowledgeBaseId: string;
+        modelId?: string;
+    };
+    condition?: {
+        conditions: Array<{
+            name: string;
+            expression: string;
+        }>;
+    };
+    lex?: {
+        botAliasArn: string;
+        localeId: string;
+    };
+    prompt?: {
+        sourceConfiguration: {
+            resource?: {
+                promptArn: string;
+            };
+            inline?: {
+                modelId: string;
+                templateType: 'TEXT';
+                templateConfiguration: {
+                    text: {
+                        text: string;
+                        inputVariables?: Array<{
+                            name: string;
+                        }>;
+                    };
+                };
+                inferenceConfiguration?: {
+                    text?: {
+                        temperature?: number;
+                        topP?: number;
+                        maxTokens?: number;
+                        stopSequences?: string[];
+                    };
+                };
+            };
+        };
+    };
+    lambdaFunction?: {
+        lambdaArn: string;
+    };
+    agent?: {
+        agentAliasArn: string;
+    };
+    storage?: {
+        serviceConfiguration: {
+            s3?: {
+                bucketName: string;
+            };
+        };
+    };
+    retrieval?: {
+        serviceConfiguration: {
+            s3?: {
+                bucketName: string;
+            };
+        };
+    };
+    iterator?: Record<string, never>;
+    collector?: Record<string, never>;
+}
+export interface FlowNode {
+    name: string;
+    type: 'Input' | 'Output' | 'KnowledgeBase' | 'Condition' | 'Lex' | 'Prompt' | 'LambdaFunction' | 'Agent' | 'Storage' | 'Retrieval' | 'Iterator' | 'Collector';
+    configuration?: FlowNodeConfiguration;
+    inputs?: Array<{
+        name: string;
+        type: 'String' | 'Number' | 'Boolean' | 'Object' | 'Array';
+        expression: string;
+    }>;
+    outputs?: Array<{
+        name: string;
+        type: 'String' | 'Number' | 'Boolean' | 'Object' | 'Array';
+    }>;
+}
+export interface FlowConnection {
+    name: string;
+    source: string;
+    target: string;
+    type: 'Data' | 'Conditional';
+    configuration?: {
+        data?: {
+            sourceOutput: string;
+            targetInput: string;
+        };
+        conditional?: {
+            condition: string;
+        };
+    };
+}
+export interface CreateFlowCommandInput {
+    name: string;
+    description?: string;
+    executionRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    definition?: {
+        nodes?: FlowNode[];
+        connections?: FlowConnection[];
+    };
+    clientToken?: string;
+    tags?: Record<string, string>;
+}
+export interface CreateFlowCommandOutput {
+    name: string;
+    description?: string;
+    executionRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    id: string;
+    arn: string;
+    status: 'NotPrepared' | 'Preparing' | 'Prepared' | 'Failed';
+    createdAt: string;
+    updatedAt: string;
+    version: string;
+    definition?: {
+        nodes?: FlowNode[];
+        connections?: FlowConnection[];
+    };
+}
+export interface GetFlowCommandInput {
+    flowIdentifier: string;
+}
+export interface GetFlowCommandOutput {
+    name: string;
+    description?: string;
+    executionRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    id: string;
+    arn: string;
+    status: 'NotPrepared' | 'Preparing' | 'Prepared' | 'Failed';
+    createdAt: string;
+    updatedAt: string;
+    version: string;
+    definition?: {
+        nodes?: FlowNode[];
+        connections?: FlowConnection[];
+    };
+    validations?: Array<{
+        message: string;
+        severity: 'Warning' | 'Error';
+    }>;
+}
+export interface ListFlowsCommandInput {
+    maxResults?: number;
+    nextToken?: string;
+}
+export interface ListFlowsCommandOutput {
+    flowSummaries: Array<{
+        name: string;
+        description?: string;
+        id: string;
+        arn: string;
+        status: 'NotPrepared' | 'Preparing' | 'Prepared' | 'Failed';
+        createdAt: string;
+        updatedAt: string;
+        version: string;
+    }>;
+    nextToken?: string;
+}
+export interface UpdateFlowCommandInput {
+    flowIdentifier: string;
+    name: string;
+    description?: string;
+    executionRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    definition?: {
+        nodes?: FlowNode[];
+        connections?: FlowConnection[];
+    };
+}
+export interface UpdateFlowCommandOutput {
+    name: string;
+    description?: string;
+    executionRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    id: string;
+    arn: string;
+    status: 'NotPrepared' | 'Preparing' | 'Prepared' | 'Failed';
+    createdAt: string;
+    updatedAt: string;
+    version: string;
+    definition?: {
+        nodes?: FlowNode[];
+        connections?: FlowConnection[];
+    };
+}
+export interface DeleteFlowCommandInput {
+    flowIdentifier: string;
+    skipResourceInUseCheck?: boolean;
+}
+export interface DeleteFlowCommandOutput {
+    id: string;
+}
+export interface PrepareFlowCommandInput {
+    flowIdentifier: string;
+}
+export interface PrepareFlowCommandOutput {
+    id: string;
+    status: 'NotPrepared' | 'Preparing' | 'Prepared' | 'Failed';
+}
+export interface CreateFlowVersionCommandInput {
+    flowIdentifier: string;
+    description?: string;
+    clientToken?: string;
+}
+export interface CreateFlowVersionCommandOutput {
+    name: string;
+    description?: string;
+    executionRoleArn: string;
+    customerEncryptionKeyArn?: string;
+    id: string;
+    arn: string;
+    status: 'NotPrepared' | 'Preparing' | 'Prepared' | 'Failed';
+    createdAt: string;
+    version: string;
+    definition?: {
+        nodes?: FlowNode[];
+        connections?: FlowConnection[];
+    };
+}
+export interface CreateFlowAliasCommandInput {
+    flowIdentifier: string;
+    name: string;
+    description?: string;
+    routingConfiguration: Array<{
+        flowVersion: string;
+    }>;
+    clientToken?: string;
+    tags?: Record<string, string>;
+}
+export interface CreateFlowAliasCommandOutput {
+    name: string;
+    description?: string;
+    routingConfiguration: Array<{
+        flowVersion: string;
+    }>;
+    flowId: string;
+    id: string;
+    arn: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InvokeFlowCommandInput {
+    flowIdentifier: string;
+    flowAliasIdentifier: string;
+    inputs: Array<{
+        nodeName: string;
+        nodeOutputName: string;
+        content: {
+            document?: unknown;
+        };
+    }>;
+}
+export interface InvokeFlowCommandOutput {
+    responseStream: AsyncIterable<{
+        flowOutputEvent?: {
+            nodeName: string;
+            nodeType: string;
+            content: {
+                document?: unknown;
+            };
+        };
+        flowCompletionEvent?: {
+            completionReason: 'SUCCESS';
+        };
+    }>;
+}
+export interface S3DataSourceConfiguration {
+    bucketArn: string;
+    inclusionPrefixes?: string[];
+    bucketOwnerAccountId?: string;
+}
+export interface ConfluenceDataSourceConfiguration {
+    sourceConfiguration: {
+        hostUrl: string;
+        hostType: 'SAAS';
+        authType: 'BASIC' | 'OAUTH2_CLIENT_CREDENTIALS';
+        credentialsSecretArn: string;
+    };
+    crawlerConfiguration?: {
+        filterConfiguration?: {
+            type: 'PATTERN';
+            patternObjectFilter?: {
+                filters: Array<{
+                    objectType: 'Attachment' | 'Blog' | 'Comment' | 'Page' | 'Space';
+                    inclusionFilters?: string[];
+                    exclusionFilters?: string[];
+                }>;
+            };
+        };
+    };
+}
+export interface SalesforceDataSourceConfiguration {
+    sourceConfiguration: {
+        hostUrl: string;
+        authType: 'OAUTH2_CLIENT_CREDENTIALS';
+        credentialsSecretArn: string;
+    };
+    crawlerConfiguration?: {
+        filterConfiguration?: {
+            type: 'PATTERN';
+            patternObjectFilter?: {
+                filters: Array<{
+                    objectType: 'Account' | 'Case' | 'Campaign' | 'Contact' | 'Contract' | 'Document' | 'Lead' | 'Opportunity' | 'Partner' | 'PricebookEntry' | 'Product2' | 'Solution' | 'Task';
+                    inclusionFilters?: string[];
+                    exclusionFilters?: string[];
+                }>;
+            };
+        };
+    };
+}
+export interface SharePointDataSourceConfiguration {
+    sourceConfiguration: {
+        siteUrls: string[];
+        hostType: 'ONLINE';
+        authType: 'OAUTH2_CLIENT_CREDENTIALS';
+        credentialsSecretArn: string;
+        tenantId?: string;
+        domain: string;
+    };
+    crawlerConfiguration?: {
+        filterConfiguration?: {
+            type: 'PATTERN';
+            patternObjectFilter?: {
+                filters: Array<{
+                    objectType: 'Page' | 'File' | 'Event' | 'Attachment';
+                    inclusionFilters?: string[];
+                    exclusionFilters?: string[];
+                }>;
+            };
+        };
+    };
+}
+export interface WebDataSourceConfiguration {
+    sourceConfiguration: {
+        urlConfiguration: {
+            seedUrls: Array<{
+                url: string;
+            }>;
+        };
+    };
+    crawlerConfiguration?: {
+        crawlerLimits?: {
+            rateLimit?: number;
+        };
+        inclusionFilters?: string[];
+        exclusionFilters?: string[];
+        scope?: 'HOST_ONLY' | 'SUBDOMAINS';
+    };
+}
+export interface CreateDataSourceCommandInput {
+    knowledgeBaseId: string;
+    clientToken?: string;
+    name: string;
+    description?: string;
+    dataSourceConfiguration: {
+        type: 'S3' | 'CONFLUENCE' | 'SALESFORCE' | 'SHAREPOINT' | 'WEB';
+        s3Configuration?: S3DataSourceConfiguration;
+        confluenceConfiguration?: ConfluenceDataSourceConfiguration;
+        salesforceConfiguration?: SalesforceDataSourceConfiguration;
+        sharePointConfiguration?: SharePointDataSourceConfiguration;
+        webConfiguration?: WebDataSourceConfiguration;
+    };
+    dataDeletionPolicy?: 'RETAIN' | 'DELETE';
+    serverSideEncryptionConfiguration?: {
+        kmsKeyArn?: string;
+    };
+    vectorIngestionConfiguration?: {
+        chunkingConfiguration?: {
+            chunkingStrategy: 'FIXED_SIZE' | 'NONE' | 'HIERARCHICAL' | 'SEMANTIC';
+            fixedSizeChunkingConfiguration?: {
+                maxTokens: number;
+                overlapPercentage: number;
+            };
+            hierarchicalChunkingConfiguration?: {
+                levelConfigurations: Array<{
+                    maxTokens: number;
+                }>;
+                overlapTokens: number;
+            };
+            semanticChunkingConfiguration?: {
+                maxTokens: number;
+                bufferSize: number;
+                breakpointPercentileThreshold: number;
+            };
+        };
+        parsingConfiguration?: {
+            parsingStrategy: 'BEDROCK_FOUNDATION_MODEL';
+            bedrockFoundationModelConfiguration?: {
+                modelArn: string;
+                parsingPrompt?: {
+                    parsingPromptText: string;
+                };
+            };
+        };
+        customTransformationConfiguration?: {
+            intermediateStorage: {
+                s3Location: {
+                    uri: string;
+                };
+            };
+            transformations: Array<{
+                stepToApply: 'POST_CHUNKING';
+                transformationFunction: {
+                    transformationLambdaConfiguration: {
+                        lambdaArn: string;
+                    };
+                };
+            }>;
+        };
+    };
+}
+export interface CreateDataSourceCommandOutput {
+    dataSource: {
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        name: string;
+        description?: string;
+        status: 'AVAILABLE' | 'DELETING' | 'DELETE_UNSUCCESSFUL';
+        dataSourceConfiguration: {
+            type: string;
+            s3Configuration?: S3DataSourceConfiguration;
+        };
+        dataDeletionPolicy?: string;
+        serverSideEncryptionConfiguration?: {
+            kmsKeyArn?: string;
+        };
+        vectorIngestionConfiguration?: {
+            chunkingConfiguration?: {
+                chunkingStrategy: string;
+            };
+        };
+        createdAt: string;
+        updatedAt: string;
+        failureReasons?: string[];
+    };
+}
+export interface GetDataSourceCommandInput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+}
+export interface GetDataSourceCommandOutput {
+    dataSource: {
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        name: string;
+        description?: string;
+        status: 'AVAILABLE' | 'DELETING' | 'DELETE_UNSUCCESSFUL';
+        dataSourceConfiguration: {
+            type: string;
+            s3Configuration?: S3DataSourceConfiguration;
+        };
+        dataDeletionPolicy?: string;
+        serverSideEncryptionConfiguration?: {
+            kmsKeyArn?: string;
+        };
+        vectorIngestionConfiguration?: {
+            chunkingConfiguration?: {
+                chunkingStrategy: string;
+            };
+        };
+        createdAt: string;
+        updatedAt: string;
+        failureReasons?: string[];
+    };
+}
+export interface ListDataSourcesCommandInput {
+    knowledgeBaseId: string;
+    maxResults?: number;
+    nextToken?: string;
+}
+export interface ListDataSourcesCommandOutput {
+    dataSourceSummaries: Array<{
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        name: string;
+        description?: string;
+        status: 'AVAILABLE' | 'DELETING' | 'DELETE_UNSUCCESSFUL';
+        updatedAt: string;
+    }>;
+    nextToken?: string;
+}
+export interface UpdateDataSourceCommandInput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+    name: string;
+    description?: string;
+    dataSourceConfiguration: {
+        type: 'S3' | 'CONFLUENCE' | 'SALESFORCE' | 'SHAREPOINT' | 'WEB';
+        s3Configuration?: S3DataSourceConfiguration;
+        confluenceConfiguration?: ConfluenceDataSourceConfiguration;
+        salesforceConfiguration?: SalesforceDataSourceConfiguration;
+        sharePointConfiguration?: SharePointDataSourceConfiguration;
+        webConfiguration?: WebDataSourceConfiguration;
+    };
+    dataDeletionPolicy?: 'RETAIN' | 'DELETE';
+    serverSideEncryptionConfiguration?: {
+        kmsKeyArn?: string;
+    };
+    vectorIngestionConfiguration?: {
+        chunkingConfiguration?: {
+            chunkingStrategy: 'FIXED_SIZE' | 'NONE' | 'HIERARCHICAL' | 'SEMANTIC';
+            fixedSizeChunkingConfiguration?: {
+                maxTokens: number;
+                overlapPercentage: number;
+            };
+        };
+    };
+}
+export interface UpdateDataSourceCommandOutput {
+    dataSource: {
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        name: string;
+        description?: string;
+        status: 'AVAILABLE' | 'DELETING' | 'DELETE_UNSUCCESSFUL';
+        dataSourceConfiguration: {
+            type: string;
+            s3Configuration?: S3DataSourceConfiguration;
+        };
+        dataDeletionPolicy?: string;
+        serverSideEncryptionConfiguration?: {
+            kmsKeyArn?: string;
+        };
+        vectorIngestionConfiguration?: {
+            chunkingConfiguration?: {
+                chunkingStrategy: string;
+            };
+        };
+        createdAt: string;
+        updatedAt: string;
+        failureReasons?: string[];
+    };
+}
+export interface DeleteDataSourceCommandInput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+}
+export interface DeleteDataSourceCommandOutput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+    status: string;
+}
+export interface StartIngestionJobCommandInput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+    clientToken?: string;
+    description?: string;
+}
+export interface StartIngestionJobCommandOutput {
+    ingestionJob: {
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        ingestionJobId: string;
+        description?: string;
+        status: 'STARTING' | 'IN_PROGRESS' | 'COMPLETE' | 'FAILED' | 'STOPPING' | 'STOPPED';
+        statistics?: {
+            numberOfDocumentsScanned?: number;
+            numberOfNewDocumentsIndexed?: number;
+            numberOfModifiedDocumentsIndexed?: number;
+            numberOfDocumentsDeleted?: number;
+            numberOfDocumentsFailed?: number;
+        };
+        failureReasons?: string[];
+        startedAt: string;
+        updatedAt: string;
+    };
+}
+export interface GetIngestionJobCommandInput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+    ingestionJobId: string;
+}
+export interface GetIngestionJobCommandOutput {
+    ingestionJob: {
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        ingestionJobId: string;
+        description?: string;
+        status: 'STARTING' | 'IN_PROGRESS' | 'COMPLETE' | 'FAILED' | 'STOPPING' | 'STOPPED';
+        statistics?: {
+            numberOfDocumentsScanned?: number;
+            numberOfNewDocumentsIndexed?: number;
+            numberOfModifiedDocumentsIndexed?: number;
+            numberOfDocumentsDeleted?: number;
+            numberOfDocumentsFailed?: number;
+        };
+        failureReasons?: string[];
+        startedAt: string;
+        updatedAt: string;
+    };
+}
+export interface ListIngestionJobsCommandInput {
+    knowledgeBaseId: string;
+    dataSourceId: string;
+    filters?: Array<{
+        attribute: 'STATUS';
+        operator: 'EQ';
+        values: string[];
+    }>;
+    sortBy?: {
+        attribute: 'STARTED_AT' | 'STATUS';
+        order: 'ASCENDING' | 'DESCENDING';
+    };
+    maxResults?: number;
+    nextToken?: string;
+}
+export interface ListIngestionJobsCommandOutput {
+    ingestionJobSummaries: Array<{
+        knowledgeBaseId: string;
+        dataSourceId: string;
+        ingestionJobId: string;
+        description?: string;
+        status: 'STARTING' | 'IN_PROGRESS' | 'COMPLETE' | 'FAILED' | 'STOPPING' | 'STOPPED';
+        startedAt: string;
+        updatedAt: string;
+        statistics?: {
+            numberOfDocumentsScanned?: number;
+            numberOfNewDocumentsIndexed?: number;
+            numberOfModifiedDocumentsIndexed?: number;
+            numberOfDocumentsDeleted?: number;
+            numberOfDocumentsFailed?: number;
+        };
+    }>;
+    nextToken?: string;
+}
+export interface CreateModelCopyJobCommandInput {
+    sourceModelArn: string;
+    targetModelName: string;
+    modelKmsKeyId?: string;
+    targetModelTags?: Array<{
+        key: string;
+        value: string;
+    }>;
+    clientRequestToken?: string;
+}
+export interface CreateModelCopyJobCommandOutput {
+    jobArn: string;
+}
+export interface GetModelCopyJobCommandInput {
+    jobArn: string;
+}
+export interface GetModelCopyJobCommandOutput {
+    jobArn: string;
+    status: 'InProgress' | 'Completed' | 'Failed';
+    creationTime: string;
+    targetModelArn?: string;
+    targetModelName: string;
+    sourceAccountId: string;
+    sourceModelArn: string;
+    targetModelKmsKeyArn?: string;
+    targetModelTags?: Array<{
+        key: string;
+        value: string;
+    }>;
+    failureMessage?: string;
+}
+export interface ListModelCopyJobsCommandInput {
+    creationTimeAfter?: string;
+    creationTimeBefore?: string;
+    statusEquals?: 'InProgress' | 'Completed' | 'Failed';
+    sourceAccountEquals?: string;
+    sourceModelArnEquals?: string;
+    targetModelNameContains?: string;
+    maxResults?: number;
+    nextToken?: string;
+    sortBy?: 'CreationTime';
+    sortOrder?: 'Ascending' | 'Descending';
+}
+export interface ListModelCopyJobsCommandOutput {
+    nextToken?: string;
+    modelCopyJobSummaries?: Array<{
+        jobArn: string;
+        status: 'InProgress' | 'Completed' | 'Failed';
+        creationTime: string;
+        targetModelArn?: string;
+        targetModelName: string;
+        sourceAccountId: string;
+        sourceModelArn: string;
+        targetModelKmsKeyArn?: string;
+        failureMessage?: string;
+    }>;
+}
+/**
+ * Request access to multiple Bedrock models
+ * Convenience function matching the pattern from the user's example
+ */
+export declare function requestModelAccess(models: string[], region?: string): Promise<Array<{
+    modelId: string;
+    status: string;
+    error?: string;
+}>>;
+/**
+ * List all available Claude models in the region
+ */
+export declare function listClaudeModels(region?: string): Promise<FoundationModelSummary[]>;
+/**
+ * Create a simple text completion using Claude
+ */
+export declare function completeWithClaude(prompt: string, options?: {
+    modelId?: string;
+    maxTokens?: number;
+    temperature?: number;
+    region?: string;
+}): Promise<string>;
+/**
+ * Generate embeddings for text
+ */
+export declare function generateEmbeddings(text: string | string[], options?: {
+    modelId?: string;
+    region?: string;
+}): Promise<number[] | number[][]>;