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[][]>;
