export interface MemoryRecordCreateInput {
    /** A client-provided identifier for tracking this specific record creation request. */
    requestIdentifier: string;
    /** A list of namespace identifiers that categorize or group the memory record. */
    namespaces: any[];
    /** The content to be stored within the memory record. */
    content: any;
    /** Time at which the memory record was created. */
    timestamp: string;
    /** The ID of the memory strategy that defines how this memory record is grouped. */
    memoryStrategyId?: string;
}
export interface MemoryRecordDeleteInput {
    /** The unique ID of the memory record to be deleted. */
    memoryRecordId: string;
}
export interface MemoryRecordUpdateInput {
    /** The unique ID of the memory record to be updated. */
    memoryRecordId: string;
    /** Time at which the memory record was updated */
    timestamp: string;
    /** The content to be stored within the memory record. */
    content?: any;
    /** The updated list of namespace identifiers for categorizing the memory record. */
    namespaces?: any[];
    /** The updated ID of the memory strategy that defines how this memory record is grouped. */
    memoryStrategyId?: string;
}
export interface Branch {
    /** The identifier of the root event for this branch. */
    rootEventId?: string;
    /** The name of the branch. */
    name: string;
}
export interface ToolArguments {
    /** The code to execute in a code interpreter session. This is the source code in the specified programming language that will be executed by the code interpreter. */
    code?: string;
    /** The programming language of the code to execute. This tells the code interpreter which language runtime to use for execution. Common values include 'python', 'javascript', and 'r'. */
    language?: 'python' | 'javascript' | 'typescript';
    /** Whether to clear the context for the tool. */
    clearContext?: boolean;
    /** The command to execute with the tool. */
    command?: string;
    /** The path for the tool operation. */
    path?: string;
    /** The paths for the tool operation. */
    paths?: string[];
    /** The content for the tool operation. */
    content?: any[];
    /** The directory path for the tool operation. */
    directoryPath?: string;
    /** The identifier of the task for the tool operation. */
    taskId?: string;
}
export interface BranchFilter {
    /** The name of the branch to filter by. */
    name: string;
    /** Specifies whether to include parent branches in the results. Set to true to include parent branches, or false to exclude them. */
    includeParentBranches?: boolean;
}
export interface FilterInput {
    /** The branch filter criteria to apply when listing events. */
    branch?: BranchFilter;
    /** Event metadata filter criteria to apply when retrieving events. */
    eventMetadata?: any[];
}
export interface ExtractionJobFilterInput {
    /** The memory strategy identifier to filter extraction jobs by. If specified, only extraction jobs with this strategy ID are returned. */
    strategyId?: string;
    /** The unique identifier of the session. If specified, only extraction jobs with this session ID are returned. */
    sessionId?: string;
    /** The identifier of the actor. If specified, only extraction jobs with this actor ID are returned. */
    actorId?: string;
    /** The status of the extraction job. If specified, only extraction jobs with this status are returned. */
    status?: 'FAILED';
}
export interface SearchCriteria {
    /** The search query to use for finding relevant memory records. */
    searchQuery: string;
    /** The memory strategy identifier to filter memory records by. */
    memoryStrategyId?: string;
    /** The maximum number of top-scoring memory records to return. This value is used for semantic search ranking. */
    topK?: number;
    /** Filters to apply to metadata associated with a memory. */
    metadataFilters?: any[];
}
export interface ViewPort {
    /** The width of the viewport in pixels. This value determines the horizontal dimension of the visible area. Valid values range from 800 to 1920 pixels. */
    width: number;
    /** The height of the viewport in pixels. This value determines the vertical dimension of the visible area. Valid values range from 600 to 1080 pixels. */
    height: number;
}
export interface BrowserExtension {
    /** The location where the browser extension files are stored. This specifies the source from which the extension will be loaded and installed. */
    location: any;
}
export interface BrowserProfileConfiguration {
    /** The unique identifier of the browser profile. This identifier is used to reference the profile when starting new browser sessions or saving session data to the profile. */
    profileIdentifier: string;
}
export interface ProxyBypass {
    /** Array of domain patterns that should bypass the proxy. Supports .amazonaws.com for subdomain matching or amazonaws.com for exact domain matching. Requests to these domains connect directly without usi */
    domainPatterns?: any[];
}
export interface ProxyConfiguration {
    /** An array of 1-5 proxy server configurations for domain-based routing. Each proxy can specify which domains it handles via domainPatterns, enabling flexible routing of different traffic through differe */
    proxies: any[];
    /** Optional configuration for domains that should bypass all proxies and connect directly to their destination, like the internet. Takes precedence over all proxy routing rules. */
    bypass?: ProxyBypass;
}
export interface ExtractionJob {
    /** The unique identifier of the extraction job. */
    jobId: string;
}
export interface AutomationStreamUpdate {
    /** The status of the automation stream. */
    streamStatus?: 'ENABLED' | 'DISABLED';
}
export interface BatchCreateMemoryRecordsInput {
    /** The unique ID of the memory resource where records will be created. */
    memoryId: string;
    /** A list of memory record creation inputs to be processed in the batch operation. */
    records: MemoryRecordCreateInput[];
    /** A unique, case-sensitive identifier to ensure idempotent processing of the batch request. */
    clientToken?: string;
}
export interface BatchDeleteMemoryRecordsInput {
    /** The unique ID of the memory resource where records will be deleted. */
    memoryId: string;
    /** A list of memory record deletion inputs to be processed in the batch operation. */
    records: MemoryRecordDeleteInput[];
}
export interface BatchUpdateMemoryRecordsInput {
    /** The unique ID of the memory resource where records will be updated. */
    memoryId: string;
    /** A list of memory record update inputs to be processed in the batch operation. */
    records: MemoryRecordUpdateInput[];
}
export interface CompleteResourceTokenAuthInput {
    /** Unique identifier for the user's authentication session for retrieving OAuth2 tokens. This ID tracks the authorization flow state across multiple requests and responses during the OAuth2 authenticatio */
    sessionUri: string;
    /** The OAuth2.0 token or user ID that was used to generate the workload access token used for initiating the user authorization flow to retrieve OAuth2.0 tokens. */
    userIdentifier: {
        userToken?: string;
    } | {
        userId?: string;
    };
}
export interface CreateEventInput {
    /** The identifier of the actor associated with this event. An actor represents an entity that participates in sessions and generates events. */
    actorId: string;
    /** The timestamp when the event occurred. If not specified, the current time is used. */
    eventTimestamp: string;
    /** The identifier of the AgentCore Memory resource in which to create the event. */
    memoryId: string;
    /** The content payload of the event. This can include conversational data or binary content. */
    payload: {
        conversational?: any;
    } | {
        blob?: any;
    }[];
    /** The branch information for this event. Branches allow for organizing events into different conversation threads or paths. */
    branch?: Branch;
    /** A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, AgentCore ignores the request, but does not return an error. */
    clientToken?: string;
    /** The key-value metadata to attach to the event. */
    metadata?: Record<string, {
        stringValue?: string;
    }>;
    /** The identifier of the session in which this event occurs. A session represents a sequence of related events. */
    sessionId?: string;
}
export interface DeleteEventInput {
    /** The identifier of the actor associated with the event to delete. */
    actorId: string;
    /** The identifier of the event to delete. */
    eventId: string;
    /** The identifier of the AgentCore Memory resource from which to delete the event. */
    memoryId: string;
    /** The identifier of the session containing the event to delete. */
    sessionId: string;
}
export interface DeleteMemoryRecordInput {
    /** The identifier of the AgentCore Memory resource from which to delete the memory record. */
    memoryId: string;
    /** The identifier of the memory record to delete. */
    memoryRecordId: string;
}
export interface EvaluateInput {
    /** The input data containing agent session spans to be evaluated. Includes a list of spans in OpenTelemetry format from supported frameworks like Strands (AgentCore Runtime) or LangGraph with OpenInferen */
    evaluationInput: {
        sessionSpans?: any[];
    };
    /** The unique identifier of the evaluator to use for scoring. Can be a built-in evaluator (e.g., Builtin.Helpfulness, Builtin.Correctness) or a custom evaluator ARN created through the control plane API. */
    evaluatorId: string;
    /** The specific trace or span IDs to evaluate within the provided input. Allows targeting evaluation at different levels: individual tool calls, single request-response interactions (traces), or entire c */
    evaluationTarget?: {
        spanIds?: string[];
    } | {
        traceIds?: string[];
    };
}
export interface GetAgentCardInput {
    /** The ARN of the AgentCore Runtime agent for which you want to get the A2A agent card. */
    agentRuntimeArn: string;
    /** Optional qualifier to specify an agent alias, such as prodcode&gt; or dev. If you don't provide a value, the DEFAULT alias is used. */
    qualifier?: string;
    /** The session ID that the AgentCore Runtime agent is using. */
    runtimeSessionId?: string;
}
export interface GetBrowserSessionInput {
    /** The unique identifier of the browser associated with the session. */
    browserIdentifier: string;
    /** The unique identifier of the browser session to retrieve. */
    sessionId: string;
}
export interface GetCodeInterpreterSessionInput {
    /** The unique identifier of the code interpreter associated with the session. */
    codeInterpreterIdentifier: string;
    /** The unique identifier of the code interpreter session to retrieve. */
    sessionId: string;
}
export interface GetEventInput {
    /** The identifier of the actor associated with the event. */
    actorId: string;
    /** The identifier of the event to retrieve. */
    eventId: string;
    /** The identifier of the AgentCore Memory resource containing the event. */
    memoryId: string;
    /** The identifier of the session containing the event. */
    sessionId: string;
}
export interface GetMemoryRecordInput {
    /** The identifier of the AgentCore Memory resource containing the memory record. */
    memoryId: string;
    /** The identifier of the memory record to retrieve. */
    memoryRecordId: string;
}
export interface GetResourceApiKeyInput {
    /** The credential provider name for the resource from which you are retrieving the API key. */
    resourceCredentialProviderName: string;
    /** The identity token of the workload from which you want to retrieve the API key. */
    workloadIdentityToken: string;
}
export interface GetResourceOauth2TokenInput {
    /** The type of flow to be performed. */
    oauth2Flow: 'USER_FEDERATION' | 'M2M';
    /** The name of the resource's credential provider. */
    resourceCredentialProviderName: string;
    /** The OAuth scopes being requested. */
    scopes: string[];
    /** The identity token of the workload from which you want to retrieve the OAuth2 token. */
    workloadIdentityToken: string;
    /** A map of custom parameters to include in the authorization request to the resource credential provider. These parameters are in addition to the standard OAuth 2.0 flow parameters, and will not overrid */
    customParameters?: Record<string, string>;
    /** An opaque string that will be sent back to the callback URL provided in resourceOauth2ReturnUrl. This state should be used to protect the callback URL of your application against CSRF attacks by ensur */
    customState?: string;
    /** Indicates whether to always initiate a new three-legged OAuth (3LO) flow, regardless of any existing session. */
    forceAuthentication?: boolean;
    /** The callback URL to redirect to after the OAuth 2.0 token retrieval is complete. This URL must be one of the provided URLs configured for the workload identity. */
    resourceOauth2ReturnUrl?: string;
    /** Unique identifier for the user's authentication session for retrieving OAuth2 tokens. This ID tracks the authorization flow state across multiple requests and responses during the OAuth2 authenticatio */
    sessionUri?: string;
}
export interface GetWorkloadAccessTokenInput {
    /** The unique identifier for the registered workload. */
    workloadName: string;
}
export interface GetWorkloadAccessTokenForJWTInput {
    /** The OAuth 2.0 token issued by the user's identity provider. */
    userToken: string;
    /** The unique identifier for the registered workload. */
    workloadName: string;
}
export interface GetWorkloadAccessTokenForUserIdInput {
    /** The ID of the user for whom you are retrieving the access token. */
    userId: string;
    /** The name of the workload from which you want to retrieve the access token. */
    workloadName: string;
}
export interface InvokeAgentRuntimeInput {
    /** The Amazon Web Services Resource Name (ARN) of the agent runtime to invoke. The ARN uniquely identifies the agent runtime resource in Amazon Bedrock AgentCore. */
    agentRuntimeArn: string;
    /** The input data to send to the agent runtime. The format of this data depends on the specific agent configuration and must match the specified content type. For most agents, this is a JSON object conta */
    payload: string;
    /** The desired MIME type for the response from the agent runtime. This tells the agent runtime what format to use for the response data. Common values include application/json for JSON data. */
    accept?: string;
    /** The identifier of the Amazon Web Services account for the agent runtime resource. */
    accountId?: string;
    /** Additional context information for distributed tracing. */
    baggage?: string;
    /** The MIME type of the input data in the payload. This tells the agent runtime how to interpret the payload data. Common values include application/json for JSON data. */
    contentType?: string;
    /** The version of the MCP protocol being used. */
    mcpProtocolVersion?: string;
    /** The identifier of the MCP session. */
    mcpSessionId?: string;
    /** The qualifier to use for the agent runtime. This can be a version number or an endpoint name that points to a specific version. If not specified, Amazon Bedrock AgentCore uses the default version of t */
    qualifier?: string;
    /** The identifier of the runtime session. */
    runtimeSessionId?: string;
    /** The identifier of the runtime user. */
    runtimeUserId?: string;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
    /** The trace state information for distributed tracing. */
    traceState?: string;
}
export interface InvokeCodeInterpreterInput {
    /** The unique identifier of the code interpreter associated with the session. This must match the identifier used when creating the session with StartCodeInterpreterSession. */
    codeInterpreterIdentifier: string;
    /** The name of the code interpreter to invoke. */
    name: 'executeCode' | 'executeCommand' | 'readFiles' | 'listFiles' | 'removeFiles' | 'writeFiles' | 'startCommandExecution' | 'getTask' | 'stopTask';
    /** The arguments for the code interpreter. This includes the code to execute and any additional parameters such as the programming language, whether to clear the execution context, and other execution op */
    arguments?: ToolArguments;
    /** The unique identifier of the code interpreter session to use. This must be an active session created with StartCodeInterpreterSession. If the session has expired or been stopped, the request will fail */
    sessionId?: string;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
}
export interface ListActorsInput {
    /** The identifier of the AgentCore Memory resource for which to list actors. */
    memoryId: string;
    /** The maximum number of results to return in a single call. The default value is 20. */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. */
    nextToken?: string;
}
export interface ListBrowserSessionsInput {
    /** The unique identifier of the browser to list sessions for. If specified, only sessions for this browser are returned. If not specified, sessions for all browsers are returned. */
    browserIdentifier: string;
    /** The maximum number of results to return in a single call. The default value is 10. Valid values range from 1 to 100. To retrieve the remaining results, make another call with the returned nextToken va */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. If not specified, Amazon Bedrock AgentCore returns the f */
    nextToken?: string;
    /** The status of the browser sessions to list. Valid values include ACTIVE, STOPPING, and STOPPED. If not specified, sessions with any status are returned. */
    status?: 'READY' | 'TERMINATED';
}
export interface ListCodeInterpreterSessionsInput {
    /** The unique identifier of the code interpreter to list sessions for. If specified, only sessions for this code interpreter are returned. If not specified, sessions for all code interpreters are returne */
    codeInterpreterIdentifier: string;
    /** The maximum number of results to return in a single call. The default value is 10. Valid values range from 1 to 100. To retrieve the remaining results, make another call with the returned nextToken va */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. If not specified, Amazon Bedrock AgentCore returns the f */
    nextToken?: string;
    /** The status of the code interpreter sessions to list. Valid values include ACTIVE, STOPPING, and STOPPED. If not specified, sessions with any status are returned. */
    status?: 'READY' | 'TERMINATED';
}
export interface ListEventsInput {
    /** The identifier of the actor for which to list events. */
    actorId: string;
    /** The identifier of the AgentCore Memory resource for which to list events. */
    memoryId: string;
    /** The identifier of the session for which to list events. */
    sessionId: string;
    /** Filter criteria to apply when listing events. */
    filter?: FilterInput;
    /** Specifies whether to include event payloads in the response. Set to true to include payloads, or false to exclude them. */
    includePayloads?: boolean;
    /** The maximum number of results to return in a single call. The default value is 20. */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. */
    nextToken?: string;
}
export interface ListMemoryExtractionJobsInput {
    /** The unique identifier of the memory to list extraction jobs for. */
    memoryId: string;
    /** Filter criteria to apply when listing extraction jobs. */
    filter?: ExtractionJobFilterInput;
    /** The maximum number of results to return in a single call. The default value is 20. */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. */
    nextToken?: string;
}
export interface ListMemoryRecordsInput {
    /** The identifier of the AgentCore Memory resource for which to list memory records. */
    memoryId: string;
    /** The namespace prefix to filter memory records by. Returns all memory records in namespaces that start with the provided prefix. */
    namespace: string;
    /** The maximum number of results to return in a single call. The default value is 20. */
    maxResults?: number;
    /** The memory strategy identifier to filter memory records by. If specified, only memory records with this strategy ID are returned. */
    memoryStrategyId?: string;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. */
    nextToken?: string;
}
export interface ListSessionsInput {
    /** The identifier of the actor for which to list sessions. */
    actorId: string;
    /** The identifier of the AgentCore Memory resource for which to list sessions. */
    memoryId: string;
    /** The maximum number of results to return in a single call. The default value is 20. */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. */
    nextToken?: string;
}
export interface RetrieveMemoryRecordsInput {
    /** The identifier of the AgentCore Memory resource from which to retrieve memory records. */
    memoryId: string;
    /** The namespace prefix to filter memory records by. Searches for memory records in namespaces that start with the provided prefix. */
    namespace: string;
    /** The search criteria to use for finding relevant memory records. This includes the search query, memory strategy ID, and other search parameters. */
    searchCriteria: SearchCriteria;
    /** The maximum number of results to return in a single call. The default value is 20. */
    maxResults?: number;
    /** The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. */
    nextToken?: string;
}
export interface SaveBrowserSessionProfileInput {
    /** The unique identifier of the browser associated with the session from which to save the profile. */
    browserIdentifier: string;
    /** The unique identifier for the browser profile. This identifier is used to reference the profile when starting new browser sessions. The identifier must follow the pattern of an alphanumeric name (up t */
    profileIdentifier: string;
    /** The unique identifier of the browser session from which to save the profile. The session must be active when saving the profile. */
    sessionId: string;
    /** A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock AgentCore ignores the request, but does not */
    clientToken?: string;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
}
export interface StartBrowserSessionInput {
    /** The unique identifier of the browser to use for this session. This identifier specifies which browser environment to initialize for the session. */
    browserIdentifier: string;
    /** A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock AgentCore ignores the request, but does not */
    clientToken?: string;
    /** A list of browser extensions to load into the browser session. */
    extensions?: BrowserExtension[];
    /** The name of the browser session. This name helps you identify and manage the session. The name does not need to be unique. */
    name?: string;
    /** The browser profile configuration to use for this session. A browser profile contains persistent data such as cookies and local storage that can be reused across multiple browser sessions. If specifie */
    profileConfiguration?: BrowserProfileConfiguration;
    /** Optional proxy configuration for routing browser traffic through customer-specified proxy servers. When provided, enables HTTP Basic authentication via Amazon Web Services Secrets Manager and domain-b */
    proxyConfiguration?: ProxyConfiguration;
    /** The time in seconds after which the session automatically terminates if there is no activity. The default value is 3600 seconds (1 hour). The minimum allowed value is 60 seconds, and the maximum allow */
    sessionTimeoutSeconds?: number;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
    /** The dimensions of the browser viewport for this session. This determines the visible area of the web content and affects how web pages are rendered. If not specified, Amazon Bedrock AgentCore uses a d */
    viewPort?: ViewPort;
}
export interface StartCodeInterpreterSessionInput {
    /** The unique identifier of the code interpreter to use for this session. This identifier specifies which code interpreter environment to initialize for the session. */
    codeInterpreterIdentifier: string;
    /** A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock AgentCore ignores the request, but does not */
    clientToken?: string;
    /** The name of the code interpreter session. This name helps you identify and manage the session. The name does not need to be unique. */
    name?: string;
    /** The time in seconds after which the session automatically terminates if there is no activity. The default value is 900 seconds (15 minutes). The minimum allowed value is 60 seconds, and the maximum al */
    sessionTimeoutSeconds?: number;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
}
export interface StartMemoryExtractionJobInput {
    /** Extraction job to start in this operation. */
    extractionJob: ExtractionJob;
    /** The unique identifier of the memory for which to start extraction jobs. */
    memoryId: string;
    /** A unique, case-sensitive identifier to ensure idempotent processing of the request. */
    clientToken?: string;
}
export interface StopBrowserSessionInput {
    /** The unique identifier of the browser associated with the session. */
    browserIdentifier: string;
    /** The unique identifier of the browser session to stop. */
    sessionId: string;
    /** A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock AgentCore ignores the request, but does not */
    clientToken?: string;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
}
export interface StopCodeInterpreterSessionInput {
    /** The unique identifier of the code interpreter associated with the session. */
    codeInterpreterIdentifier: string;
    /** The unique identifier of the code interpreter session to stop. */
    sessionId: string;
    /** A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock AgentCore ignores the request, but does not */
    clientToken?: string;
    /** The trace identifier for request tracking. */
    traceId?: string;
    /** The parent trace information for distributed tracing. */
    traceParent?: string;
}
export interface StopRuntimeSessionInput {
    /** The ARN of the agent that contains the session that you want to stop. */
    agentRuntimeArn: string;
    /** The ID of the session that you want to stop. */
    runtimeSessionId: string;
    /** Idempotent token used to identify the request. If you use the same token with multiple requests, the same response is returned. Use ClientToken to prevent the same request from being processed more th */
    clientToken?: string;
    /** Optional qualifier to specify an agent alias, such as prodcode&gt; or dev. If you don't provide a value, the DEFAULT alias is used. */
    qualifier?: string;
}
export interface UpdateBrowserStreamInput {
    /** The identifier of the browser. */
    browserIdentifier: string;
    /** The identifier of the browser session. */
    sessionId: string;
    /** The update to apply to the browser stream. */
    streamUpdate: {
        automationStreamUpdate?: AutomationStreamUpdate;
    };
    /** A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an e */
    clientToken?: string;
}
/** Bedrock AgentCore service binding for Step Functions SDK integrations. */
export declare class BedrockAgentCore {
    constructor();
    batchCreateMemoryRecords<T>(params: BatchCreateMemoryRecordsInput): Promise<T>;
    batchDeleteMemoryRecords<T>(params: BatchDeleteMemoryRecordsInput): Promise<T>;
    batchUpdateMemoryRecords<T>(params: BatchUpdateMemoryRecordsInput): Promise<T>;
    completeResourceTokenAuth<T>(params: CompleteResourceTokenAuthInput): Promise<T>;
    createEvent<T>(params: CreateEventInput): Promise<T>;
    deleteEvent<T>(params: DeleteEventInput): Promise<T>;
    deleteMemoryRecord<T>(params: DeleteMemoryRecordInput): Promise<T>;
    evaluate<T>(params: EvaluateInput): Promise<T>;
    getAgentCard<T>(params: GetAgentCardInput): Promise<T>;
    getBrowserSession<T>(params: GetBrowserSessionInput): Promise<T>;
    getCodeInterpreterSession<T>(params: GetCodeInterpreterSessionInput): Promise<T>;
    getEvent<T>(params: GetEventInput): Promise<T>;
    getMemoryRecord<T>(params: GetMemoryRecordInput): Promise<T>;
    getResourceApiKey<T>(params: GetResourceApiKeyInput): Promise<T>;
    getResourceOauth2Token<T>(params: GetResourceOauth2TokenInput): Promise<T>;
    getWorkloadAccessToken<T>(params: GetWorkloadAccessTokenInput): Promise<T>;
    getWorkloadAccessTokenForJWT<T>(params: GetWorkloadAccessTokenForJWTInput): Promise<T>;
    getWorkloadAccessTokenForUserId<T>(params: GetWorkloadAccessTokenForUserIdInput): Promise<T>;
    invokeAgentRuntime<T>(params: InvokeAgentRuntimeInput): Promise<T>;
    invokeCodeInterpreter<T>(params: InvokeCodeInterpreterInput): Promise<T>;
    listActors<T>(params: ListActorsInput): Promise<T>;
    listBrowserSessions<T>(params: ListBrowserSessionsInput): Promise<T>;
    listCodeInterpreterSessions<T>(params: ListCodeInterpreterSessionsInput): Promise<T>;
    listEvents<T>(params: ListEventsInput): Promise<T>;
    listMemoryExtractionJobs<T>(params: ListMemoryExtractionJobsInput): Promise<T>;
    listMemoryRecords<T>(params: ListMemoryRecordsInput): Promise<T>;
    listSessions<T>(params: ListSessionsInput): Promise<T>;
    retrieveMemoryRecords<T>(params: RetrieveMemoryRecordsInput): Promise<T>;
    saveBrowserSessionProfile<T>(params: SaveBrowserSessionProfileInput): Promise<T>;
    startBrowserSession<T>(params: StartBrowserSessionInput): Promise<T>;
    startCodeInterpreterSession<T>(params: StartCodeInterpreterSessionInput): Promise<T>;
    startMemoryExtractionJob<T>(params: StartMemoryExtractionJobInput): Promise<T>;
    stopBrowserSession<T>(params: StopBrowserSessionInput): Promise<T>;
    stopCodeInterpreterSession<T>(params: StopCodeInterpreterSessionInput): Promise<T>;
    stopRuntimeSession<T>(params: StopRuntimeSessionInput): Promise<T>;
    updateBrowserStream<T>(params: UpdateBrowserStreamInput): Promise<T>;
}
//# sourceMappingURL=BedrockAgentCore.d.ts.map