@mastra/client-js 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/dist/client.d.ts

@@ -1,121 +1,158 @@
-import type { AITraceRecord, AITracesPaginatedArg, WorkflowInfo } from '@mastra/core';
+import type { ListScoresResponse, Trajectory } from '@mastra/core/evals';
 import type { ServerDetailInfo } from '@mastra/core/mcp';
-import type { RuntimeContext } from '@mastra/core/runtime-context';
-import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, A2A, MCPTool, AgentBuilder } from './resources/index.js';
-import { NetworkMemoryThread } from './resources/network-memory-thread.js';
-import type { ClientOptions, CreateMemoryThreadParams, CreateMemoryThreadResponse, GetAgentResponse, GetLogParams, GetLogsParams, GetLogsResponse, GetMemoryThreadParams, GetMemoryThreadResponse, GetTelemetryParams, GetTelemetryResponse, GetToolResponse, GetWorkflowResponse, SaveMessageToMemoryParams, SaveMessageToMemoryResponse, McpServerListResponse, McpServerToolListResponse, GetNetworkMemoryThreadParams, CreateNetworkMemoryThreadParams, SaveNetworkMessageToMemoryParams, GetScorerResponse, GetScoresByScorerIdParams, GetScoresResponse, GetScoresByRunIdParams, GetScoresByEntityIdParams, GetScoresBySpanParams, SaveScoreParams, SaveScoreResponse, GetAITracesResponse, GetMemoryConfigParams, GetMemoryConfigResponse, GetMemoryThreadMessagesResponse } from './types.js';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { PaginationInfo, TraceRecord, GetTraceLightResponse, GetSpanResponse, ListTracesArgs, ListTracesResponse, ListTracesLightResponse, ListBranchesArgs, ListBranchesResponse, GetBranchArgs, GetBranchResponse, ListLogsArgs, ListLogsResponse, ListScoresArgs, ListScoresResponse as ListScoresResponseNew, CreateScoreBody, CreateScoreResponse, GetScoreAggregateArgs, GetScoreAggregateResponse, GetScoreBreakdownArgs, GetScoreBreakdownResponse, GetScoreTimeSeriesArgs, GetScoreTimeSeriesResponse, GetScorePercentilesArgs, GetScorePercentilesResponse, ListFeedbackArgs, ListFeedbackResponse, CreateFeedbackBody, CreateFeedbackResponse, GetFeedbackAggregateArgs, GetFeedbackAggregateResponse, GetFeedbackBreakdownArgs, GetFeedbackBreakdownResponse, GetFeedbackTimeSeriesArgs, GetFeedbackTimeSeriesResponse, GetFeedbackPercentilesArgs, GetFeedbackPercentilesResponse, GetMetricAggregateArgs, GetMetricAggregateResponse, GetMetricBreakdownArgs, GetMetricBreakdownResponse, GetMetricTimeSeriesArgs, GetMetricTimeSeriesResponse, GetMetricPercentilesArgs, GetMetricPercentilesResponse, GetMetricNamesArgs, GetMetricNamesResponse, GetMetricLabelKeysArgs, GetMetricLabelKeysResponse, GetMetricLabelValuesArgs, GetMetricLabelValuesResponse, GetEntityTypesResponse, GetEntityNamesArgs, GetEntityNamesResponse, GetServiceNamesResponse, GetEnvironmentsResponse, GetTagsArgs, GetTagsResponse } from '@mastra/core/storage';
+import type { WorkflowInfo } from '@mastra/core/workflows';
+import { Agent, MemoryThread, Tool, Processor, Workflow, Vector, BaseResource, A2A, A2AV1, MCPTool, AgentBuilder, Conversations, StoredAgent, StoredWorkflow, StoredPromptBlock, StoredMCPClient, StoredScorer, StoredSkill, ToolProvider, ProcessorProvider, Workspace, Responses, Channels, AgentController } from './resources/index.js';
+import type { ListScoresBySpanParams, LegacyTracesPaginatedArg, LegacyGetTracesResponse } from './resources/observability.js';
+import type { ClientOptions, CreateMemoryThreadParams, CreateMemoryThreadResponse, GetAgentResponse, AgentVersionIdentifier, GetLogParams, GetLogsParams, GetLogsResponse, GetToolResponse, GetProcessorResponse, GetWorkflowResponse, SaveMessageToMemoryParams, SaveMessageToMemoryResponse, McpServerListResponse, McpServerToolListResponse, GetScorerResponse, ListScoresByScorerIdParams, ListScoresByRunIdParams, ListScoresByEntityIdParams, SaveScoreParams, SaveScoreResponse, GetMemoryConfigParams, GetMemoryConfigResponse, ListMemoryThreadMessagesResponse, MemorySearchResponse, ListAgentsModelProvidersResponse, ListMemoryThreadsParams, ListMemoryThreadsResponse, ListStoredAgentsParams, ListStoredAgentsResponse, CreateStoredAgentParams, StoredAgentResponse, ListStoredWorkflowsParams, ListStoredWorkflowsResponse, UpsertStoredWorkflowParams, UpsertStoredWorkflowResponse, ListStoredPromptBlocksParams, ListStoredPromptBlocksResponse, CreateStoredPromptBlockParams, StoredPromptBlockResponse, ListStoredScorersParams, ListStoredScorersResponse, CreateStoredScorerParams, StoredScorerResponse, ListStoredMCPClientsParams, ListStoredMCPClientsResponse, CreateStoredMCPClientParams, StoredMCPClientResponse, ListStoredSkillsParams, ListStoredSkillsResponse, CreateStoredSkillParams, StoredSkillResponse, GetSystemPackagesResponse, BuilderSettingsResponse, BuilderAvailableModelsResponse, PermissionPatternsResponse, InfrastructureStatusResponse, ListBuilderRegistriesResponse, BuilderRegistrySearchResponse, BuilderRegistryPopularResponse, BuilderRegistryPreviewResponse, BuilderRegistryInstallBody, BuilderRegistryInstallResponse, ListScoresResponse as ListScoresResponseOld, GetObservationalMemoryParams, GetObservationalMemoryResponse, AwaitBufferStatusParams, AwaitBufferStatusResponse, GetMemoryStatusResponse, ListWorkspacesResponse, ListStoredWorkspacesParams, ListStoredWorkspacesResponse, StoredWorkspaceResponse, ListVectorsResponse, ListEmbeddersResponse, DatasetRecord, DatasetItem, DatasetExperiment, DatasetExperimentResult, ListExperimentsParams, ExperimentReviewCounts, CreateDatasetParams, UpdateDatasetParams, AddDatasetItemParams, UpdateDatasetItemParams, BatchInsertDatasetItemsParams, BatchDeleteDatasetItemsParams, GenerateDatasetItemsParams, GeneratedItem, TriggerDatasetExperimentParams, UpdateExperimentResultParams, CompareExperimentsParams, CompareExperimentsResponse, DatasetItemVersionResponse, DatasetVersionResponse, ListToolProvidersResponse, GetProcessorProvidersResponse, ListBackgroundTasksParams, ListBackgroundTasksResponse, BackgroundTaskResponse, StreamBackgroundTasksParams, ListSchedulesParams, ListSchedulesResponse, ScheduleResponse, ListScheduleTriggersParams, ListScheduleTriggersResponse, CreateScheduleInput, UpdateScheduleInput, RunScheduleResponse } from './types.js';
 export declare class MastraClient extends BaseResource {
     private observability;
+    readonly conversations: Conversations;
+    readonly responses: Responses;
+    readonly channels: Channels;
     constructor(options: ClientOptions);
     /**
      * Retrieves all available agents
-     * @param runtimeContext - Optional runtime context to pass as query parameter
+     * @param requestContext - Optional request context to pass as query parameter
      * @returns Promise containing map of agent IDs to agent details
      */
-    getAgents(runtimeContext?: RuntimeContext | Record<string, any>): Promise<Record<string, GetAgentResponse>>;
+    listAgents(requestContext?: RequestContext | Record<string, any>, partial?: boolean): Promise<Record<string, GetAgentResponse>>;
+    listAgentsModelProviders(): Promise<ListAgentsModelProvidersResponse>;
     /**
      * Gets an agent instance by ID
      * @param agentId - ID of the agent to retrieve
+     * @param version - Optional version selector for stored agent overrides
      * @returns Agent instance
      */
-    getAgent(agentId: string): Agent;
+    getAgent(agentId: string, version?: AgentVersionIdentifier): Agent;
     /**
-     * Retrieves memory threads for a resource
-     * @param params - Parameters containing the resource ID
-     * @returns Promise containing array of memory threads
+     * Lists the agent controllers hosted on the connected Mastra instance.
+     * @returns Promise containing an array of agent controller identifiers
      */
-    getMemoryThreads(params: GetMemoryThreadParams): Promise<GetMemoryThreadResponse>;
+    listAgentControllers(): Promise<{
+        id: string;
+    }[]>;
+    /**
+     * Scopes to an agent controller hosted on the connected Mastra instance. Use
+     * `getAgentController(id).session(resourceId)` to create/resume a session,
+     * stream its events, and send messages.
+     * @param controllerId - The id the agent controller is registered under on Mastra
+     */
+    getAgentController(controllerId: string): AgentController;
+    /**
+     * Lists memory threads with optional filtering by resourceId and/or metadata
+     * @param params - Parameters containing optional filters, pagination options, and request context
+     * @returns Promise containing paginated array of memory threads with metadata
+     */
+    listMemoryThreads(params?: ListMemoryThreadsParams): Promise<ListMemoryThreadsResponse>;
     /**
      * Retrieves memory config for a resource
-     * @param params - Parameters containing the resource ID
-     * @returns Promise containing array of memory threads
+     * @param params - Parameters containing the resource ID and optional request context
+     * @returns Promise containing memory configuration
      */
     getMemoryConfig(params: GetMemoryConfigParams): Promise<GetMemoryConfigResponse>;
     /**
      * Creates a new memory thread
-     * @param params - Parameters for creating the memory thread
+     * @param params - Parameters for creating the memory thread including optional request context
      * @returns Promise containing the created memory thread
      */
     createMemoryThread(params: CreateMemoryThreadParams): Promise<CreateMemoryThreadResponse>;
     /**
      * Gets a memory thread instance by ID
      * @param threadId - ID of the memory thread to retrieve
+     * @param agentId - Optional agent ID. When not provided, uses storage directly
      * @returns MemoryThread instance
      */
-    getMemoryThread(threadId: string, agentId: string): MemoryThread;
-    getThreadMessages(threadId: string, opts?: {
+    getMemoryThread({ threadId, agentId }: {
+        threadId: string;
         agentId?: string;
-        networkId?: string;
-    }): Promise<GetMemoryThreadMessagesResponse>;
-    deleteThread(threadId: string, opts?: {
+    }): MemoryThread;
+    /**
+     * Lists messages for a thread.
+     * @param threadId - ID of the thread
+     * @param opts - Optional parameters including agentId, networkId, and requestContext
+     *   - When agentId is provided, uses the agent's memory
+     *   - When networkId is provided, uses the network endpoint
+     *   - When neither is provided, uses storage directly
+     * @returns Promise containing the thread messages
+     */
+    listThreadMessages(threadId: string, opts?: {
         agentId?: string;
         networkId?: string;
+        requestContext?: RequestContext | Record<string, any>;
+        includeSystemReminders?: boolean;
+    }): Promise<ListMemoryThreadMessagesResponse>;
+    deleteThread(threadId: string, opts: {
+        agentId: string;
+        networkId?: never;
+        requestContext?: RequestContext | Record<string, any>;
+    } | {
+        networkId: string;
+        agentId?: never;
+        requestContext?: RequestContext | Record<string, any>;
     }): Promise<{
         success: boolean;
         message: string;
     }>;
     /**
      * Saves messages to memory
-     * @param params - Parameters containing messages to save
+     * @param params - Parameters containing messages to save and optional request context
      * @returns Promise containing the saved messages
      */
     saveMessageToMemory(params: SaveMessageToMemoryParams): Promise<SaveMessageToMemoryResponse>;
     /**
      * Gets the status of the memory system
-     * @returns Promise containing memory system status
-     */
-    getMemoryStatus(agentId: string): Promise<{
-        result: boolean;
-    }>;
-    /**
-     * Retrieves memory threads for a resource
-     * @param params - Parameters containing the resource ID
-     * @returns Promise containing array of memory threads
-     */
-    getNetworkMemoryThreads(params: GetNetworkMemoryThreadParams): Promise<GetMemoryThreadResponse>;
-    /**
-     * Creates a new memory thread
-     * @param params - Parameters for creating the memory thread
-     * @returns Promise containing the created memory thread
-     */
-    createNetworkMemoryThread(params: CreateNetworkMemoryThreadParams): Promise<CreateMemoryThreadResponse>;
-    /**
-     * Gets a memory thread instance by ID
-     * @param threadId - ID of the memory thread to retrieve
-     * @returns MemoryThread instance
+     * @param agentId - The agent ID
+     * @param opts - Optional parameters including resourceId, threadId, and requestContext
+     * @returns Promise containing memory system status including observational memory info
      */
-    getNetworkMemoryThread(threadId: string, networkId: string): NetworkMemoryThread;
+    getMemoryStatus(agentId: string, requestContext?: RequestContext | Record<string, any>, opts?: {
+        resourceId?: string;
+        threadId?: string;
+    }): Promise<GetMemoryStatusResponse>;
     /**
-     * Saves messages to memory
-     * @param params - Parameters containing messages to save
-     * @returns Promise containing the saved messages
+     * Gets observational memory data for a resource or thread
+     * @param params - Parameters containing agentId, resourceId, threadId, and optional request context
+     * @returns Promise containing the current OM record and history
      */
-    saveNetworkMessageToMemory(params: SaveNetworkMessageToMemoryParams): Promise<SaveMessageToMemoryResponse>;
+    getObservationalMemory(params: GetObservationalMemoryParams): Promise<GetObservationalMemoryResponse>;
     /**
-     * Gets the status of the memory system
-     * @returns Promise containing memory system status
+     * Blocks until any in-flight observational memory buffering completes, then returns the updated record
+     * @param params - Parameters containing agentId, resourceId, threadId
+     * @returns Promise containing the updated OM record after buffering completes
      */
-    getNetworkMemoryStatus(networkId: string): Promise<{
-        result: boolean;
-    }>;
+    awaitBufferStatus(params: AwaitBufferStatusParams): Promise<AwaitBufferStatusResponse>;
     /**
      * Retrieves all available tools
-     * @param runtimeContext - Optional runtime context to pass as query parameter
+     * @param requestContext - Optional request context to pass as query parameter
      * @returns Promise containing map of tool IDs to tool details
      */
-    getTools(runtimeContext?: RuntimeContext | Record<string, any>): Promise<Record<string, GetToolResponse>>;
+    listTools(requestContext?: RequestContext | Record<string, any>): Promise<Record<string, GetToolResponse>>;
     /**
      * Gets a tool instance by ID
      * @param toolId - ID of the tool to retrieve
      * @returns Tool instance
      */
     getTool(toolId: string): Tool;
+    /**
+     * Retrieves all available processors
+     * @param requestContext - Optional request context to pass as query parameter
+     * @returns Promise containing map of processor IDs to processor details
+     */
+    listProcessors(requestContext?: RequestContext | Record<string, any>): Promise<Record<string, GetProcessorResponse>>;
+    /**
+     * Gets a processor instance by ID
+     * @param processorId - ID of the processor to retrieve
+     * @returns Processor instance
+     */
+    getProcessor(processorId: string): Processor;
     /**
      * Retrieves all available workflows
-     * @param runtimeContext - Optional runtime context to pass as query parameter
+     * @param requestContext - Optional request context to pass as query parameter
      * @returns Promise containing map of workflow IDs to workflow details
      */
-    getWorkflows(runtimeContext?: RuntimeContext | Record<string, any>): Promise<Record<string, GetWorkflowResponse>>;
+    listWorkflows(requestContext?: RequestContext | Record<string, any>, partial?: boolean): Promise<Record<string, GetWorkflowResponse>>;
     /**
      * Gets a workflow instance by ID
      * @param workflowId - ID of the workflow to retrieve
@@ -143,7 +180,7 @@ export declare class MastraClient extends BaseResource {
      * @param params - Parameters for filtering logs
      * @returns Promise containing array of log messages
      */
-    getLogs(params: GetLogsParams): Promise<GetLogsResponse>;
+    listLogs(params: GetLogsParams): Promise<GetLogsResponse>;
     /**
      * Gets logs for a specific run
      * @param params - Parameters containing run ID to retrieve
@@ -154,23 +191,21 @@ export declare class MastraClient extends BaseResource {
      * List of all log transports
      * @returns Promise containing list of log transports
      */
-    getLogTransports(): Promise<{
+    listLogTransports(): Promise<{
         transports: string[];
     }>;
-    /**
-     * List of all traces (paged)
-     * @param params - Parameters for filtering traces
-     * @returns Promise containing telemetry data
-     */
-    getTelemetry(params?: GetTelemetryParams): Promise<GetTelemetryResponse>;
     /**
      * Retrieves a list of available MCP servers.
-     * @param params - Optional parameters for pagination (limit, offset).
+     * @param params - Optional parameters for pagination (page, perPage, or deprecated offset, limit).
      * @returns Promise containing the list of MCP servers and pagination info.
      */
     getMcpServers(params?: {
-        limit?: number;
+        page?: number;
+        perPage?: number;
+        /** @deprecated Use page instead */
         offset?: number;
+        /** @deprecated Use perPage instead */
+        limit?: number;
     }): Promise<McpServerListResponse>;
     /**
      * Retrieves detailed information for a specific MCP server.
@@ -195,12 +230,45 @@ export declare class MastraClient extends BaseResource {
      * @returns MCPTool instance.
      */
     getMcpServerTool(serverId: string, toolId: string): MCPTool;
+    /**
+     * Lists resources available on an MCP server.
+     * @param serverId - The ID of the MCP server.
+     * @returns Promise containing the list of resources.
+     */
+    getMcpServerResources(serverId: string): Promise<{
+        resources: Array<{
+            uri: string;
+            name: string;
+            description?: string;
+            mimeType?: string;
+            _meta?: Record<string, unknown>;
+        }>;
+    }>;
+    /**
+     * Reads the content of a resource from an MCP server.
+     * Used for fetching ui:// MCP App HTML content.
+     * @param serverId - The ID of the MCP server.
+     * @param uri - The resource URI to read.
+     * @returns Promise containing the resource content.
+     */
+    readMcpServerResource(serverId: string, uri: string): Promise<{
+        contents: Array<{
+            uri: string;
+            text?: string;
+            blob?: string;
+        }>;
+    }>;
     /**
      * Gets an A2A client for interacting with an agent via the A2A protocol
      * @param agentId - ID of the agent to interact with
      * @returns A2A client instance
      */
     getA2A(agentId: string): A2A;
+    /**
+     * Gets an A2A Protocol v1.0 client for an agent.
+     * @param agentId - ID of the agent to interact with
+     */
+    getA2AV1(agentId: string): A2AV1;
     /**
      * Retrieves the working memory for a specific thread (optionally resource-scoped).
      * @param agentId - ID of the agent.
@@ -208,11 +276,20 @@ export declare class MastraClient extends BaseResource {
      * @param resourceId - Optional ID of the resource.
      * @returns Working memory for the specified thread or resource.
      */
-    getWorkingMemory({ agentId, threadId, resourceId, }: {
+    getWorkingMemory({ agentId, threadId, resourceId, requestContext, }: {
         agentId: string;
         threadId: string;
         resourceId?: string;
+        requestContext?: RequestContext | Record<string, any>;
     }): Promise<unknown>;
+    searchMemory({ agentId, resourceId, threadId, searchQuery, memoryConfig, requestContext, }: {
+        agentId: string;
+        resourceId: string;
+        threadId?: string;
+        searchQuery: string;
+        memoryConfig?: any;
+        requestContext?: RequestContext | Record<string, any>;
+    }): Promise<MemorySearchResponse>;
     /**
      * Updates the working memory for a specific thread (optionally resource-scoped).
      * @param agentId - ID of the agent.
@@ -220,50 +297,92 @@ export declare class MastraClient extends BaseResource {
      * @param workingMemory - The new working memory content.
      * @param resourceId - Optional ID of the resource.
      */
-    updateWorkingMemory({ agentId, threadId, workingMemory, resourceId, }: {
+    updateWorkingMemory({ agentId, threadId, workingMemory, resourceId, requestContext, }: {
         agentId: string;
         threadId: string;
         workingMemory: string;
         resourceId?: string;
+        requestContext?: RequestContext | Record<string, any>;
     }): Promise<unknown>;
     /**
      * Retrieves all available scorers
+     * @param requestContext - Optional request context to pass as query parameter
      * @returns Promise containing list of available scorers
      */
-    getScorers(): Promise<Record<string, GetScorerResponse>>;
+    listScorers(requestContext?: RequestContext | Record<string, any>): Promise<Record<string, GetScorerResponse>>;
     /**
      * Retrieves a scorer by ID
      * @param scorerId - ID of the scorer to retrieve
      * @returns Promise containing the scorer
      */
     getScorer(scorerId: string): Promise<GetScorerResponse>;
-    getScoresByScorerId(params: GetScoresByScorerIdParams): Promise<GetScoresResponse>;
+    listScoresByScorerId(params: ListScoresByScorerIdParams): Promise<ListScoresResponseOld>;
     /**
      * Retrieves scores by run ID
      * @param params - Parameters containing run ID and pagination options
      * @returns Promise containing scores and pagination info
      */
-    getScoresByRunId(params: GetScoresByRunIdParams): Promise<GetScoresResponse>;
+    listScoresByRunId(params: ListScoresByRunIdParams): Promise<ListScoresResponseOld>;
     /**
      * Retrieves scores by entity ID and type
      * @param params - Parameters containing entity ID, type, and pagination options
      * @returns Promise containing scores and pagination info
      */
-    getScoresByEntityId(params: GetScoresByEntityIdParams): Promise<GetScoresResponse>;
+    listScoresByEntityId(params: ListScoresByEntityIdParams): Promise<ListScoresResponseOld>;
     /**
      * Saves a score
      * @param params - Parameters containing the score data to save
      * @returns Promise containing the saved score
      */
     saveScore(params: SaveScoreParams): Promise<SaveScoreResponse>;
-    /**
-     * Retrieves model providers with available keys
-     * @returns Promise containing model providers with available keys
-     */
-    getModelProviders(): Promise<string[]>;
-    getAITrace(traceId: string): Promise<AITraceRecord>;
-    getAITraces(params: AITracesPaginatedArg): Promise<GetAITracesResponse>;
-    getScoresBySpan(params: GetScoresBySpanParams): Promise<GetScoresResponse>;
+    /** Retrieves a specific trace by ID. */
+    getTrace(traceId: string): Promise<TraceRecord>;
+    /** Retrieves a lightweight trace by ID (timeline fields only, excludes heavy fields). */
+    getTraceLight(traceId: string): Promise<GetTraceLightResponse>;
+    /** Retrieves a single span with full details by trace ID and span ID. */
+    getSpan(traceId: string, spanId: string): Promise<GetSpanResponse>;
+    /** Extracts a structured trajectory from a trace's spans. */
+    getTraceTrajectory(traceId: string): Promise<Trajectory>;
+    /**
+     * Retrieves paginated list of traces with optional filtering.
+     * This is the legacy API preserved for backward compatibility.
+     *
+     * @param params - Parameters for pagination and filtering (legacy format)
+     * @returns Promise containing paginated traces and pagination info
+     * @deprecated Use {@link listTraces} instead for new features like ordering and more filters.
+     */
+    getTraces(params: LegacyTracesPaginatedArg): Promise<LegacyGetTracesResponse>;
+    /**
+     * Retrieves paginated list of traces with optional filtering and sorting.
+     * This is the new API with improved filtering options.
+     *
+     * @param params - Parameters for pagination, filtering, and ordering
+     * @returns Promise containing paginated traces and pagination info
+     */
+    listTraces(params?: ListTracesArgs): Promise<ListTracesResponse>;
+    /**
+     * Retrieves paginated list of traces carrying only the fields a trace list renders.
+     * Same contract as {@link listTraces}, but rows omit the `attributes`/`input`/`output`
+     * blobs and carry a short `inputPreview` instead.
+     *
+     * @param params - Parameters for pagination, filtering, and ordering
+     * @returns Promise containing paginated lightweight traces and pagination info
+     */
+    listTracesLight(params?: ListTracesArgs): Promise<ListTracesLightResponse>;
+    /**
+     * Retrieves a paginated list of trace branches with optional filtering and sorting.
+     * Each row is a branch-anchor span (AGENT_RUN, WORKFLOW_RUN, TOOL_CALL, etc.) including
+     * ones nested under a different root entity. Pairs with {@link getBranch} to expand
+     * a single branch into its subtree.
+     */
+    listBranches(params?: ListBranchesArgs): Promise<ListBranchesResponse>;
+    /**
+     * Retrieves the subtree of spans rooted at a given span. The optional `depth` field
+     * bounds descendant levels below the anchor (0 = anchor only; omitted = full subtree).
+     */
+    getBranch(params: GetBranchArgs): Promise<GetBranchResponse>;
+    listScoresBySpan(params: ListScoresBySpanParams): Promise<ListScoresResponse>;
+    /** Scores one or more traces using a specified scorer (fire-and-forget). */
     score(params: {
         scorerName: string;
         targets: Array<{
@@ -274,5 +393,573 @@ export declare class MastraClient extends BaseResource {
         status: string;
         message: string;
     }>;
+    /** Retrieves a paginated list of observability logs. */
+    listLogsVNext(params?: ListLogsArgs): Promise<ListLogsResponse>;
+    /** Retrieves a paginated list of observability scores. */
+    listScores(params?: ListScoresArgs): Promise<ListScoresResponseNew>;
+    /** Creates a single score record in the observability store. */
+    createScore(params: CreateScoreBody): Promise<CreateScoreResponse>;
+    /** Returns an aggregated score value with optional period-over-period comparison. */
+    getScoreAggregate(params: GetScoreAggregateArgs): Promise<GetScoreAggregateResponse>;
+    /** Returns score values grouped by specified dimensions. */
+    getScoreBreakdown(params: GetScoreBreakdownArgs): Promise<GetScoreBreakdownResponse>;
+    /** Returns score values bucketed by time interval with optional grouping. */
+    getScoreTimeSeries(params: GetScoreTimeSeriesArgs): Promise<GetScoreTimeSeriesResponse>;
+    /** Returns percentile values for scores bucketed by time interval. */
+    getScorePercentiles(params: GetScorePercentilesArgs): Promise<GetScorePercentilesResponse>;
+    /** Retrieves a paginated list of feedback records. */
+    listFeedback(params?: ListFeedbackArgs): Promise<ListFeedbackResponse>;
+    /** Creates a single feedback record in the observability store. */
+    createFeedback(params: CreateFeedbackBody): Promise<CreateFeedbackResponse>;
+    /** Returns an aggregated feedback value with optional period-over-period comparison. */
+    getFeedbackAggregate(params: GetFeedbackAggregateArgs): Promise<GetFeedbackAggregateResponse>;
+    /** Returns feedback values grouped by specified dimensions. */
+    getFeedbackBreakdown(params: GetFeedbackBreakdownArgs): Promise<GetFeedbackBreakdownResponse>;
+    /** Returns feedback values bucketed by time interval with optional grouping. */
+    getFeedbackTimeSeries(params: GetFeedbackTimeSeriesArgs): Promise<GetFeedbackTimeSeriesResponse>;
+    /** Returns percentile values for feedback bucketed by time interval. */
+    getFeedbackPercentiles(params: GetFeedbackPercentilesArgs): Promise<GetFeedbackPercentilesResponse>;
+    /** Returns an aggregated metric value with optional period-over-period comparison. */
+    getMetricAggregate(params: GetMetricAggregateArgs): Promise<GetMetricAggregateResponse>;
+    /** Returns metric values grouped by specified dimensions. */
+    getMetricBreakdown(params: GetMetricBreakdownArgs): Promise<GetMetricBreakdownResponse>;
+    /** Returns metric values bucketed by time interval with optional grouping. */
+    getMetricTimeSeries(params: GetMetricTimeSeriesArgs): Promise<GetMetricTimeSeriesResponse>;
+    /** Returns percentile values for a metric bucketed by time interval. */
+    getMetricPercentiles(params: GetMetricPercentilesArgs): Promise<GetMetricPercentilesResponse>;
+    /** Returns distinct metric names with optional prefix filtering. */
+    getMetricNames(params?: GetMetricNamesArgs): Promise<GetMetricNamesResponse>;
+    /** Returns distinct label keys for a given metric. */
+    getMetricLabelKeys(params: GetMetricLabelKeysArgs): Promise<GetMetricLabelKeysResponse>;
+    /** Returns distinct values for a given metric label key. */
+    getMetricLabelValues(params: GetMetricLabelValuesArgs): Promise<GetMetricLabelValuesResponse>;
+    /** Returns distinct entity types from observability data. */
+    getEntityTypes(): Promise<GetEntityTypesResponse>;
+    /** Returns distinct entity names with optional type filtering. */
+    getEntityNames(params?: GetEntityNamesArgs): Promise<GetEntityNamesResponse>;
+    /** Returns distinct service names from observability data. */
+    getServiceNames(): Promise<GetServiceNamesResponse>;
+    /** Returns distinct environments from observability data. */
+    getEnvironments(): Promise<GetEnvironmentsResponse>;
+    /** Returns distinct tags with optional entity type filtering. */
+    getTags(params?: GetTagsArgs): Promise<GetTagsResponse>;
+    /**
+     * Lists all stored agents with optional pagination
+     * @param params - Optional pagination and ordering parameters
+     * @returns Promise containing paginated list of stored agents
+     */
+    listStoredAgents(params?: ListStoredAgentsParams): Promise<ListStoredAgentsResponse>;
+    /**
+     * Creates a new stored agent
+     * @param params - Agent configuration including id, name, instructions, model, etc.
+     * @returns Promise containing the created stored agent
+     */
+    createStoredAgent(params: CreateStoredAgentParams): Promise<StoredAgentResponse>;
+    /**
+     * Gets a stored agent instance by ID for further operations (details, update, delete)
+     * @param storedAgentId - ID of the stored agent to retrieve
+     * @returns StoredAgent instance
+     */
+    getStoredAgent(storedAgentId: string): StoredAgent;
+    /**
+     * Lists stored workflow definitions, optionally filtered by status or author
+     * @param params - Optional filters: `status` ('active' | 'archived') and `authorId`
+     * @returns Promise containing the matching definitions and a total count
+     */
+    listStoredWorkflows(params?: ListStoredWorkflowsParams): Promise<ListStoredWorkflowsResponse>;
+    /**
+     * Creates or replaces a stored workflow definition and live-registers it on the server.
+     * Optional `dependencies` lets helper workflows referenced by the root definition be
+     * saved in the same request; their ids are echoed back as `dependencyIds`.
+     * @param params - The workflow definition (id, schemas, graph) plus optional helper dependencies
+     * @returns Promise containing the persisted definition and any dependency ids
+     */
+    upsertStoredWorkflow(params: UpsertStoredWorkflowParams): Promise<UpsertStoredWorkflowResponse>;
+    /**
+     * Gets a stored workflow instance by ID for further operations (details, delete).
+     * To execute a stored workflow, use `getWorkflow(id).createRun()` like any other workflow.
+     * @param storedWorkflowId - ID of the stored workflow definition
+     * @returns StoredWorkflow instance
+     */
+    getStoredWorkflow(storedWorkflowId: string): StoredWorkflow;
+    /**
+     * Lists all stored prompt blocks with optional pagination
+     * @param params - Optional pagination and ordering parameters
+     * @returns Promise containing paginated list of stored prompt blocks
+     */
+    listStoredPromptBlocks(params?: ListStoredPromptBlocksParams): Promise<ListStoredPromptBlocksResponse>;
+    /**
+     * Creates a new stored prompt block
+     * @param params - Prompt block configuration including name, content, rules, etc.
+     * @returns Promise containing the created stored prompt block
+     */
+    createStoredPromptBlock(params: CreateStoredPromptBlockParams): Promise<StoredPromptBlockResponse>;
+    /**
+     * Gets a stored prompt block instance by ID for further operations (details, update, delete)
+     * @param storedPromptBlockId - ID of the stored prompt block to retrieve
+     * @returns StoredPromptBlock instance
+     */
+    getStoredPromptBlock(storedPromptBlockId: string): StoredPromptBlock;
+    /**
+     * Lists all stored scorer definitions with optional pagination
+     * @param params - Optional pagination and ordering parameters
+     * @returns Promise containing paginated list of stored scorer definitions
+     */
+    listStoredScorers(params?: ListStoredScorersParams): Promise<ListStoredScorersResponse>;
+    /**
+     * Creates a new stored scorer definition
+     * @param params - Scorer definition configuration
+     * @returns Promise containing the created stored scorer definition
+     */
+    createStoredScorer(params: CreateStoredScorerParams): Promise<StoredScorerResponse>;
+    /**
+     * Gets a stored scorer definition instance by ID for further operations (details, update, delete)
+     * @param storedScorerId - ID of the stored scorer definition
+     * @returns StoredScorer instance
+     */
+    getStoredScorer(storedScorerId: string): StoredScorer;
+    /**
+     * Lists all stored MCP clients with optional pagination
+     * @param params - Optional pagination and ordering parameters
+     * @returns Promise containing paginated list of stored MCP clients
+     */
+    listStoredMCPClients(params?: ListStoredMCPClientsParams): Promise<ListStoredMCPClientsResponse>;
+    /**
+     * Creates a new stored MCP client
+     * @param params - MCP client configuration
+     * @returns Promise containing the created stored MCP client
+     */
+    createStoredMCPClient(params: CreateStoredMCPClientParams): Promise<StoredMCPClientResponse>;
+    /**
+     * Gets a stored MCP client instance by ID for further operations (details, update, delete)
+     * @param storedMCPClientId - ID of the stored MCP client
+     * @returns StoredMCPClient instance
+     */
+    getStoredMCPClient(storedMCPClientId: string): StoredMCPClient;
+    /**
+     * Lists all stored skills with optional pagination
+     * @param params - Optional pagination and ordering parameters
+     * @returns Promise containing paginated list of stored skills
+     */
+    listStoredSkills(params?: ListStoredSkillsParams): Promise<ListStoredSkillsResponse>;
+    /**
+     * Creates a new stored skill
+     * @param params - Skill configuration
+     * @returns Promise containing the created stored skill
+     */
+    createStoredSkill(params: CreateStoredSkillParams): Promise<StoredSkillResponse>;
+    /**
+     * Gets a stored skill instance by ID for further operations (details, update, delete)
+     * @param storedSkillId - ID of the stored skill
+     * @returns StoredSkill instance
+     */
+    getStoredSkill(storedSkillId: string): StoredSkill;
+    /**
+     * Lists all registered tool providers
+     * @returns Promise containing list of tool provider info
+     */
+    listToolProviders(): Promise<ListToolProvidersResponse>;
+    /**
+     * Gets a tool provider instance by ID for further operations (listToolkits, listTools, getToolSchema)
+     * @param providerId - ID of the tool provider
+     * @returns ToolProvider instance
+     */
+    getToolProvider(providerId: string): ToolProvider;
+    /**
+     * Lists all registered processor providers
+     * @returns Promise containing list of processor provider info
+     */
+    getProcessorProviders(): Promise<GetProcessorProvidersResponse>;
+    /**
+     * Gets a processor provider instance by ID for further operations
+     * @param providerId - ID of the processor provider
+     * @returns ProcessorProvider instance
+     */
+    getProcessorProvider(providerId: string): ProcessorProvider;
+    /**
+     * Retrieves installed Mastra packages and their versions
+     * @returns Promise containing the list of installed Mastra packages
+     */
+    getSystemPackages(): Promise<GetSystemPackagesResponse>;
+    /**
+     * Retrieves agent builder settings for UI gating.
+     * Returns feature flags and configuration set by admin.
+     * @returns Promise containing builder settings
+     */
+    getBuilderSettings(): Promise<BuilderSettingsResponse>;
+    /**
+     * Retrieves the AI providers/models available under the active builder model
+     * policy. The server applies the EE allowlist, so the result can be rendered
+     * directly in the model picker.
+     * @returns Promise containing the policy-filtered providers/models
+     */
+    getBuilderAvailableModels(): Promise<BuilderAvailableModelsResponse>;
+    /**
+     * Retrieves the authoritative list of valid permission-pattern strings.
+     * Used by Studio to validate route→permission literals and gate the sidebar.
+     * @returns Promise containing the permission patterns
+     */
+    getPermissionPatterns(): Promise<PermissionPatternsResponse>;
+    /**
+     * Retrieves Agent Builder infrastructure configuration and resolution status.
+     * Requires `infrastructure:read` permission.
+     * @returns Promise containing infrastructure status
+     */
+    getInfrastructureStatus(): Promise<InfrastructureStatusResponse>;
+    /**
+     * Lists known skill registries surfaced by the Agent Builder config.
+     * Each entry reports whether the registry is enabled. Disabled or unknown
+     * registries return 404 from registry-scoped routes.
+     * Requires `stored-skills:read` permission.
+     */
+    listBuilderRegistries(): Promise<ListBuilderRegistriesResponse>;
+    /**
+     * Search a builder skill registry. The registry must be enabled or the
+     * server returns 404.
+     * Requires `stored-skills:read` permission.
+     */
+    searchBuilderRegistry(registryId: string, params: {
+        q: string;
+        limit?: number;
+    }): Promise<BuilderRegistrySearchResponse>;
+    /**
+     * Fetch the popular skills feed from a builder skill registry.
+     * Requires `stored-skills:read` permission.
+     */
+    getBuilderRegistryPopular(registryId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<BuilderRegistryPopularResponse>;
+    /**
+     * Fetch the rendered preview content for a single registry skill.
+     * Requires `stored-skills:read` permission.
+     */
+    getBuilderRegistryPreview(registryId: string, params: {
+        owner: string;
+        repo: string;
+        path: string;
+    }): Promise<BuilderRegistryPreviewResponse>;
+    /**
+     * Install a registry skill into the builder's stored-skills DB.
+     * Returns 409 when a stored skill with the derived id already exists.
+     * Requires `stored-skills:write` permission.
+     */
+    installBuilderRegistrySkill(registryId: string, body: BuilderRegistryInstallBody): Promise<BuilderRegistryInstallResponse>;
+    /**
+     * Lists all workspaces from both Mastra instance and agents
+     * @returns Promise containing array of workspace items
+     */
+    listWorkspaces(): Promise<ListWorkspacesResponse>;
+    /**
+     * Gets the workspace resource for filesystem, search, and skills operations
+     * @param workspaceId - Workspace ID to target
+     * @returns Workspace instance
+     */
+    getWorkspace(workspaceId: string): Workspace;
+    /**
+     * Lists stored workspace configurations from the database
+     * @param params - Optional filter and pagination parameters
+     * @returns Promise containing paginated list of stored workspaces
+     */
+    listStoredWorkspaces(params?: ListStoredWorkspacesParams): Promise<ListStoredWorkspacesResponse>;
+    /**
+     * Gets a specific stored workspace by ID
+     * @param id - The workspace ID
+     * @returns Promise containing the stored workspace
+     */
+    getStoredWorkspace(id: string): Promise<StoredWorkspaceResponse>;
+    /**
+     * Lists all available vector stores
+     * @returns Promise containing list of available vector stores
+     */
+    listVectors(): Promise<ListVectorsResponse>;
+    /**
+     * Lists all available embedding models
+     * @returns Promise containing list of available embedders
+     */
+    listEmbedders(): Promise<ListEmbeddersResponse>;
+    /**
+     * Lists all datasets with optional pagination
+     */
+    listDatasets(pagination?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        datasets: DatasetRecord[];
+        pagination: PaginationInfo;
+    }>;
+    /**
+     * Gets a single dataset by ID. Optionally scope the lookup to a specific
+     * tenant organization/project — the server returns 404 if the dataset does
+     * not belong to the given tenant.
+     */
+    getDataset(datasetId: string, tenancy?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<DatasetRecord>;
+    /**
+     * Creates a new dataset
+     */
+    createDataset(params: CreateDatasetParams): Promise<DatasetRecord>;
+    /**
+     * Updates a dataset. Tenancy fields, when provided, scope the existence
+     * check on the server side so that a caller can only update datasets that
+     * belong to the given tenant.
+     */
+    updateDataset(params: UpdateDatasetParams): Promise<DatasetRecord>;
+    /**
+     * Deletes a dataset. When tenancy fields are supplied, the server only
+     * deletes the dataset if it belongs to the given tenant (silent no-op
+     * otherwise).
+     */
+    deleteDataset(datasetId: string, tenancy?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Lists items in a dataset with optional pagination, search, and version filter
+     */
+    listDatasetItems(datasetId: string, params?: {
+        page?: number;
+        perPage?: number;
+        search?: string;
+        version?: number | null;
+    }): Promise<{
+        items: DatasetItem[];
+        pagination: PaginationInfo;
+    }>;
+    /**
+     * Gets a single dataset item by ID
+     */
+    getDatasetItem(datasetId: string, itemId: string): Promise<DatasetItem>;
+    /**
+     * Adds an item to a dataset
+     */
+    addDatasetItem(params: AddDatasetItemParams): Promise<DatasetItem>;
+    /**
+     * Updates a dataset item
+     */
+    updateDatasetItem(params: UpdateDatasetItemParams): Promise<DatasetItem>;
+    /**
+     * Deletes a dataset item
+     */
+    deleteDatasetItem(datasetId: string, itemId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Batch inserts items to a dataset
+     */
+    batchInsertDatasetItems(params: BatchInsertDatasetItemsParams): Promise<{
+        items: DatasetItem[];
+        count: number;
+    }>;
+    /**
+     * Batch deletes items from a dataset
+     */
+    batchDeleteDatasetItems(params: BatchDeleteDatasetItemsParams): Promise<{
+        success: boolean;
+        deletedCount: number;
+    }>;
+    /**
+     * Generates synthetic dataset items using AI. Items are returned for review, not auto-saved.
+     */
+    generateDatasetItems(params: GenerateDatasetItemsParams): Promise<{
+        items: GeneratedItem[];
+    }>;
+    /**
+     * Cluster experiment failures using AI to identify common failure patterns.
+     */
+    clusterFailures(params: {
+        modelId: string;
+        items: Array<{
+            id: string;
+            input: unknown;
+            output?: unknown;
+            error?: string;
+            scores?: Record<string, number>;
+            existingTags?: string[];
+        }>;
+        availableTags?: string[];
+        prompt?: string;
+    }): Promise<{
+        clusters: Array<{
+            id: string;
+            label: string;
+            description: string;
+            itemIds: string[];
+        }>;
+        proposedTags?: Array<{
+            itemId: string;
+            tags: string[];
+            reason: string;
+        }>;
+    }>;
+    /**
+     * Lists versions for a dataset item
+     */
+    getItemHistory(datasetId: string, itemId: string): Promise<{
+        history: DatasetItemVersionResponse[];
+    }>;
+    /**
+     * Gets a specific version of a dataset item
+     */
+    getDatasetItemVersion(datasetId: string, itemId: string, datasetVersion: number): Promise<DatasetItemVersionResponse>;
+    /**
+     * Lists versions for a dataset
+     */
+    listDatasetVersions(datasetId: string, pagination?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        versions: DatasetVersionResponse[];
+        pagination: PaginationInfo;
+    }>;
+    /**
+     * Lists all experiments across all datasets
+     */
+    listExperiments(params?: ListExperimentsParams): Promise<{
+        experiments: DatasetExperiment[];
+        pagination: PaginationInfo;
+    }>;
+    /**
+     * Gets review status counts aggregated per experiment
+     */
+    getExperimentReviewSummary(): Promise<{
+        counts: ExperimentReviewCounts[];
+    }>;
+    /**
+     * Lists experiments for a dataset
+     */
+    listDatasetExperiments(datasetId: string, params?: ListExperimentsParams): Promise<{
+        experiments: DatasetExperiment[];
+        pagination: PaginationInfo;
+    }>;
+    /**
+     * Gets a single dataset experiment by ID
+     */
+    getDatasetExperiment(datasetId: string, experimentId: string): Promise<DatasetExperiment>;
+    /**
+     * Lists results for a dataset experiment
+     */
+    listDatasetExperimentResults(datasetId: string, experimentId: string, pagination?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        results: DatasetExperimentResult[];
+        pagination: PaginationInfo;
+    }>;
+    /**
+     * Updates an experiment result's status, tags, and/or comment
+     */
+    updateDatasetExperimentResult(params: UpdateExperimentResultParams): Promise<DatasetExperimentResult>;
+    /**
+     * Triggers a new dataset experiment
+     */
+    triggerDatasetExperiment(params: TriggerDatasetExperimentParams): Promise<{
+        experimentId: string;
+        status: 'pending' | 'running' | 'completed' | 'failed';
+        totalItems: number;
+        succeededCount: number;
+        failedCount: number;
+        startedAt: string | Date;
+        completedAt: string | Date | null;
+        results: Array<{
+            itemId: string;
+            itemDatasetVersion: number | null;
+            input: unknown;
+            output: unknown | null;
+            groundTruth: unknown | null;
+            error: string | null;
+            startedAt: string | Date;
+            completedAt: string | Date;
+            retryCount: number;
+            scores: Array<{
+                scorerId: string;
+                scorerName: string;
+                score: number | null;
+                reason: string | null;
+                error: string | null;
+            }>;
+        }>;
+    }>;
+    /**
+     * Updates the status, tags, and/or comment on an experiment result
+     */
+    updateExperimentResult(params: UpdateExperimentResultParams): Promise<DatasetExperimentResult>;
+    /**
+     * Compares two dataset experiments for regression detection
+     */
+    compareExperiments(params: CompareExperimentsParams): Promise<CompareExperimentsResponse>;
+    /**
+     * Lists background tasks with optional filtering and pagination.
+     */
+    listBackgroundTasks(params?: ListBackgroundTasksParams): Promise<ListBackgroundTasksResponse>;
+    /**
+     * Gets a single background task by ID.
+     */
+    getBackgroundTask(backgroundTaskId: string): Promise<BackgroundTaskResponse>;
+    /**
+     * Opens an SSE stream of background task events (completed/failed).
+     * Returns a Response that can be consumed as a ReadableStream.
+     */
+    streamBackgroundTasks(params?: StreamBackgroundTasksParams): Promise<import("stream/web").ReadableStream<unknown>>;
+    /**
+     * Lists schedules — agent schedules and workflow schedules — with optional
+     * filtering by agentId, workflowId, or status. Agent schedules can
+     * additionally be filtered by threadId, resourceId, or name.
+     */
+    listSchedules(params?: ListSchedulesParams): Promise<ListSchedulesResponse>;
+    /**
+     * Gets a single schedule by ID.
+     */
+    getSchedule(scheduleId: string): Promise<ScheduleResponse>;
+    /**
+     * Creates a schedule. Pass `agentId` (plus `prompt`) to schedule an agent,
+     * or `workflowId` (plus optional `inputData`) to schedule a workflow.
+     * By default each call creates a new schedule with a random id
+     * (`agent_<uuid>` for agents, `schedule_<uuid>` for workflows) — pass `id`
+     * to choose a stable id instead; creating one with an id that already
+     * exists throws.
+     *
+     * Trigger (fire) history is read through `listScheduleTriggers(schedule.id)`.
+     */
+    createSchedule(options: CreateScheduleInput): Promise<ScheduleResponse>;
+    /**
+     * Patches an existing schedule. Fields apply to the matching target type;
+     * agent-only fields on a workflow schedule are rejected. `threadId` /
+     * `resourceId` are immutable — to retarget, delete and recreate.
+     */
+    updateSchedule(scheduleId: string, patch: UpdateScheduleInput): Promise<ScheduleResponse>;
+    /**
+     * Deletes a schedule.
+     */
+    deleteSchedule(scheduleId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Fires a schedule manually, out-of-band from the cron schedule. Behaves
+     * like a scheduled fire but does not advance `nextFireAt`. The returned
+     * `claimId` is the trigger row's runId — look it up via
+     * `listScheduleTriggers(scheduleId)`.
+     */
+    runSchedule(scheduleId: string): Promise<RunScheduleResponse>;
+    /**
+     * Lists trigger history for a schedule, ordered by actualFireAt descending.
+     */
+    listScheduleTriggers(scheduleId: string, params?: ListScheduleTriggersParams): Promise<ListScheduleTriggersResponse>;
+    /**
+     * Pauses a schedule. The scheduler tick loop will skip paused schedules.
+     * Idempotent — pausing an already-paused schedule returns the current state unchanged.
+     * Pause status survives redeploys.
+     */
+    pauseSchedule(scheduleId: string): Promise<ScheduleResponse>;
+    /**
+     * Resumes a paused schedule. Recomputes nextFireAt from 'now' so a long-paused schedule
+     * does not fire a backlog. Idempotent — resuming an already-active schedule returns
+     * the current state unchanged.
+     */
+    resumeSchedule(scheduleId: string): Promise<ScheduleResponse>;
 }
 //# sourceMappingURL=client.d.ts.map