@mastra/server 1.58.0-alpha.8 → 1.58.0

package/dist/server/handlers/workflows.d.ts

@@ -6,684 +6,929 @@ export interface WorkflowContext extends Context {
     runId?: string;
     requestContext?: RequestContext;
 }
-export declare const LIST_WORKFLOWS_ROUTE: import("../server-adapter").ServerRoute<{
-    partial?: string | undefined;
-}, Record<string, {
-    steps: Record<string, {
-        id: string;
+export declare const LIST_WORKFLOWS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/workflows";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        partial?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<Record<string, {
+        steps: Record<string, {
+            id: string;
+            description?: string | undefined;
+            stateSchema?: string | undefined;
+            inputSchema?: string | undefined;
+            outputSchema?: string | undefined;
+            resumeSchema?: string | undefined;
+            suspendSchema?: string | undefined;
+            component?: string | undefined;
+            isWorkflow?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }>;
+        allSteps: Record<string, {
+            id: string;
+            description?: string | undefined;
+            stateSchema?: string | undefined;
+            inputSchema?: string | undefined;
+            outputSchema?: string | undefined;
+            resumeSchema?: string | undefined;
+            suspendSchema?: string | undefined;
+            component?: string | undefined;
+            isWorkflow?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }>;
+        stepGraph: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[];
+        name?: string | undefined;
         description?: string | undefined;
-        stateSchema?: string | undefined;
-        inputSchema?: string | undefined;
-        outputSchema?: string | undefined;
-        resumeSchema?: string | undefined;
-        suspendSchema?: string | undefined;
-        component?: string | undefined;
-        isWorkflow?: boolean | undefined;
         metadata?: Record<string, unknown> | undefined;
-    }>;
-    allSteps: Record<string, {
-        id: string;
-        description?: string | undefined;
-        stateSchema?: string | undefined;
         inputSchema?: string | undefined;
         outputSchema?: string | undefined;
-        resumeSchema?: string | undefined;
-        suspendSchema?: string | undefined;
-        component?: string | undefined;
-        isWorkflow?: boolean | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }>;
-    stepGraph: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[];
-    name?: string | undefined;
-    description?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-    inputSchema?: string | undefined;
-    outputSchema?: string | undefined;
-    stateSchema?: string | undefined;
-    options?: Record<string, never> | undefined;
-    isProcessorWorkflow?: boolean | undefined;
-    origin?: "code" | "dynamic" | undefined;
-}>, "json", import("../server-adapter").RouteSchemas<undefined, z.ZodObject<{
-    partial: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodRecord<z.ZodString, z.ZodObject<{
-    steps: z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
+        stateSchema?: string | undefined;
+        options?: Record<string, never> | undefined;
+        isProcessorWorkflow?: boolean | undefined;
+        origin?: "code" | "dynamic" | undefined;
+    }>>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<undefined, z.ZodObject<{
+        partial: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodRecord<z.ZodString, z.ZodObject<{
+        steps: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            stateSchema: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodString>;
+            resumeSchema: z.ZodOptional<z.ZodString>;
+            suspendSchema: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+            isWorkflow: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        allSteps: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            stateSchema: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodString>;
+            resumeSchema: z.ZodOptional<z.ZodString>;
+            suspendSchema: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+            isWorkflow: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        name: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
-        stateSchema: z.ZodOptional<z.ZodString>;
-        inputSchema: z.ZodOptional<z.ZodString>;
-        outputSchema: z.ZodOptional<z.ZodString>;
-        resumeSchema: z.ZodOptional<z.ZodString>;
-        suspendSchema: z.ZodOptional<z.ZodString>;
-        component: z.ZodOptional<z.ZodString>;
-        isWorkflow: z.ZodOptional<z.ZodBoolean>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    allSteps: z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        stateSchema: z.ZodOptional<z.ZodString>;
+        stepGraph: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>;
         inputSchema: z.ZodOptional<z.ZodString>;
         outputSchema: z.ZodOptional<z.ZodString>;
-        resumeSchema: z.ZodOptional<z.ZodString>;
-        suspendSchema: z.ZodOptional<z.ZodString>;
-        component: z.ZodOptional<z.ZodString>;
-        isWorkflow: z.ZodOptional<z.ZodBoolean>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    stepGraph: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>;
-    inputSchema: z.ZodOptional<z.ZodString>;
-    outputSchema: z.ZodOptional<z.ZodString>;
-    stateSchema: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
-    isProcessorWorkflow: z.ZodOptional<z.ZodBoolean>;
-    origin: z.ZodOptional<z.ZodEnum<{
-        code: "code";
-        dynamic: "dynamic";
-    }>>;
-}, z.core.$strip>>>, "GET", "/workflows">;
+        stateSchema: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+        isProcessorWorkflow: z.ZodOptional<z.ZodBoolean>;
+        origin: z.ZodOptional<z.ZodEnum<{
+            code: "code";
+            dynamic: "dynamic";
+        }>>;
+    }, z.core.$strip>>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 /** Test seam — lets TTL expiry be tested without wall-clock waits. */
 export declare function __setWorkflowRunCountsNow(now?: () => number): void;
-export declare const LIST_WORKFLOW_RUN_COUNTS_ROUTE: import("../server-adapter").ServerRoute<{}, Record<string, {
-    running: number;
-    suspended: number;
-}>, "json", import("../server-adapter").RouteSchemas<undefined, undefined, undefined, z.ZodRecord<z.ZodString, z.ZodObject<{
-    running: z.ZodNumber;
-    suspended: z.ZodNumber;
-}, z.core.$strip>>>, "GET", "/workflows/run-counts">;
-export declare const GET_WORKFLOW_BY_ID_ROUTE: import("../server-adapter").ServerRoute<{
-    workflowId: string;
-}, {
-    steps: Record<string, {
-        id: string;
+export declare const LIST_WORKFLOW_RUN_COUNTS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/workflows/run-counts";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: import("../server-adapter").ServerContext): Promise<Record<string, {
+        running: number;
+        suspended: number;
+    }>>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<undefined, undefined, undefined, z.ZodRecord<z.ZodString, z.ZodObject<{
+        running: z.ZodNumber;
+        suspended: z.ZodNumber;
+    }, z.core.$strip>>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_WORKFLOW_BY_ID_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/workflows/:workflowId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        steps: Record<string, {
+            id: string;
+            description?: string | undefined;
+            stateSchema?: string | undefined;
+            inputSchema?: string | undefined;
+            outputSchema?: string | undefined;
+            resumeSchema?: string | undefined;
+            suspendSchema?: string | undefined;
+            component?: string | undefined;
+            isWorkflow?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }>;
+        allSteps: Record<string, {
+            id: string;
+            description?: string | undefined;
+            stateSchema?: string | undefined;
+            inputSchema?: string | undefined;
+            outputSchema?: string | undefined;
+            resumeSchema?: string | undefined;
+            suspendSchema?: string | undefined;
+            component?: string | undefined;
+            isWorkflow?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }>;
+        stepGraph: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[];
+        name?: string | undefined;
         description?: string | undefined;
-        stateSchema?: string | undefined;
-        inputSchema?: string | undefined;
-        outputSchema?: string | undefined;
-        resumeSchema?: string | undefined;
-        suspendSchema?: string | undefined;
-        component?: string | undefined;
-        isWorkflow?: boolean | undefined;
         metadata?: Record<string, unknown> | undefined;
-    }>;
-    allSteps: Record<string, {
-        id: string;
-        description?: string | undefined;
-        stateSchema?: string | undefined;
         inputSchema?: string | undefined;
         outputSchema?: string | undefined;
-        resumeSchema?: string | undefined;
-        suspendSchema?: string | undefined;
-        component?: string | undefined;
-        isWorkflow?: boolean | undefined;
-        metadata?: Record<string, unknown> | undefined;
+        stateSchema?: string | undefined;
+        options?: Record<string, never> | undefined;
+        isProcessorWorkflow?: boolean | undefined;
+        origin?: "code" | "dynamic" | undefined;
     }>;
-    stepGraph: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[];
-    name?: string | undefined;
-    description?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-    inputSchema?: string | undefined;
-    outputSchema?: string | undefined;
-    stateSchema?: string | undefined;
-    options?: Record<string, never> | undefined;
-    isProcessorWorkflow?: boolean | undefined;
-    origin?: "code" | "dynamic" | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    steps: z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        steps: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            stateSchema: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodString>;
+            resumeSchema: z.ZodOptional<z.ZodString>;
+            suspendSchema: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+            isWorkflow: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        allSteps: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            stateSchema: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodString>;
+            resumeSchema: z.ZodOptional<z.ZodString>;
+            suspendSchema: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+            isWorkflow: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        name: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
-        stateSchema: z.ZodOptional<z.ZodString>;
-        inputSchema: z.ZodOptional<z.ZodString>;
-        outputSchema: z.ZodOptional<z.ZodString>;
-        resumeSchema: z.ZodOptional<z.ZodString>;
-        suspendSchema: z.ZodOptional<z.ZodString>;
-        component: z.ZodOptional<z.ZodString>;
-        isWorkflow: z.ZodOptional<z.ZodBoolean>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    allSteps: z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        stateSchema: z.ZodOptional<z.ZodString>;
+        stepGraph: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>;
         inputSchema: z.ZodOptional<z.ZodString>;
         outputSchema: z.ZodOptional<z.ZodString>;
-        resumeSchema: z.ZodOptional<z.ZodString>;
-        suspendSchema: z.ZodOptional<z.ZodString>;
-        component: z.ZodOptional<z.ZodString>;
-        isWorkflow: z.ZodOptional<z.ZodBoolean>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    stepGraph: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>;
-    inputSchema: z.ZodOptional<z.ZodString>;
-    outputSchema: z.ZodOptional<z.ZodString>;
-    stateSchema: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
-    isProcessorWorkflow: z.ZodOptional<z.ZodBoolean>;
-    origin: z.ZodOptional<z.ZodEnum<{
-        code: "code";
-        dynamic: "dynamic";
-    }>>;
-}, z.core.$strip>>, "GET", "/workflows/:workflowId">;
-export declare const LIST_WORKFLOW_RUNS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    perPage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    fromDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    toDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    resourceId: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
-    }>>;
-}, z.core.$strip>, undefined>, {
-    runs: {
-        workflowName: string;
+        stateSchema: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+        isProcessorWorkflow: z.ZodOptional<z.ZodBoolean>;
+        origin: z.ZodOptional<z.ZodEnum<{
+            code: "code";
+            dynamic: "dynamic";
+        }>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const LIST_WORKFLOW_RUNS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/workflows/:workflowId/runs";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        page?: number | undefined;
+        perPage?: number | undefined;
+        offset?: number | undefined;
+        limit?: number | undefined;
+        fromDate?: Date | undefined;
+        toDate?: Date | undefined;
+        resourceId?: string | undefined;
+        status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        runs: {
+            workflowName: string;
+            runId: string;
+            snapshot: string | import("@mastra/core/workflows").WorkflowRunState;
+            createdAt: Date;
+            updatedAt: Date;
+            resourceId?: string | undefined;
+        }[];
+        total: number;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        perPage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        fromDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+        toDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            running: "running";
+            waiting: "waiting";
+            suspended: "suspended";
+            failed: "failed";
+            canceled: "canceled";
+            pending: "pending";
+            bailed: "bailed";
+            tripwire: "tripwire";
+            paused: "paused";
+            skipped: "skipped";
+        }>>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        runs: z.ZodArray<z.ZodObject<{
+            workflowName: z.ZodString;
+            runId: z.ZodString;
+            snapshot: z.ZodType<string | import("@mastra/core/workflows").WorkflowRunState, unknown, z.core.$ZodTypeInternals<string | import("@mastra/core/workflows").WorkflowRunState, unknown>>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+            resourceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        total: z.ZodNumber;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_WORKFLOW_RUN_BY_ID_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/workflows/:workflowId/runs/:runId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+        runId: string;
+    } & {
+        fields?: string | undefined;
+        withNestedWorkflows?: "true" | "false" | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
         runId: string;
-        snapshot: string | import("@mastra/core/workflows").WorkflowRunState;
+        workflowName: string;
         createdAt: Date;
         updatedAt: Date;
+        status: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped";
         resourceId?: string | undefined;
-    }[];
-    total: number;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    perPage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    fromDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    toDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    resourceId: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
-    }>>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    runs: z.ZodArray<z.ZodObject<{
-        workflowName: z.ZodString;
+        initialState?: Record<string, unknown> | undefined;
+        result?: unknown;
+        error?: unknown;
+        payload?: unknown;
+        steps?: Record<string, unknown> | undefined;
+        activeStepsPath?: Record<string, number[]> | undefined;
+        serializedStepGraph?: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[] | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        fields: z.ZodOptional<z.ZodString>;
+        withNestedWorkflows: z.ZodOptional<z.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
         runId: z.ZodString;
-        snapshot: z.ZodType<string | import("@mastra/core/workflows").WorkflowRunState, unknown, z.core.$ZodTypeInternals<string | import("@mastra/core/workflows").WorkflowRunState, unknown>>;
+        workflowName: z.ZodString;
+        resourceId: z.ZodOptional<z.ZodString>;
         createdAt: z.ZodDate;
         updatedAt: z.ZodDate;
+        status: z.ZodEnum<{
+            success: "success";
+            running: "running";
+            waiting: "waiting";
+            suspended: "suspended";
+            failed: "failed";
+            canceled: "canceled";
+            pending: "pending";
+            bailed: "bailed";
+            tripwire: "tripwire";
+            paused: "paused";
+            skipped: "skipped";
+        }>;
+        initialState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+        serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const DELETE_WORKFLOW_RUN_BY_ID_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "DELETE";
+    path: "/workflows/:workflowId/runs/:runId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+        runId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+        runId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const CREATE_WORKFLOW_RUN_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/create-run";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId?: string | undefined;
+    } & {
+        resourceId?: string | undefined;
+        disableScorers?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        runId: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
         resourceId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    total: z.ZodNumber;
-}, z.core.$strip>>, "GET", "/workflows/:workflowId/runs">;
-export declare const GET_WORKFLOW_RUN_BY_ID_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    fields: z.ZodOptional<z.ZodString>;
-    withNestedWorkflows: z.ZodOptional<z.ZodEnum<{
-        true: "true";
-        false: "false";
-    }>>;
-}, z.core.$strip>, undefined>, {
-    runId: string;
-    workflowName: string;
-    createdAt: Date;
-    updatedAt: Date;
-    status: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped";
-    resourceId?: string | undefined;
-    initialState?: Record<string, unknown> | undefined;
-    result?: unknown;
-    error?: unknown;
-    payload?: unknown;
-    steps?: Record<string, unknown> | undefined;
-    activeStepsPath?: Record<string, number[]> | undefined;
-    serializedStepGraph?: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[] | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    fields: z.ZodOptional<z.ZodString>;
-    withNestedWorkflows: z.ZodOptional<z.ZodEnum<{
-        true: "true";
-        false: "false";
-    }>>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    runId: z.ZodString;
-    workflowName: z.ZodString;
-    resourceId: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodDate;
-    updatedAt: z.ZodDate;
-    status: z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
+        disableScorers: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const STREAM_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/stream";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        resourceId?: string | undefined;
+        inputData?: unknown;
+        initialState?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+        closeOnSuspend?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        closeOnSuspend: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, undefined> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESUME_STREAM_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/resume-stream";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step?: string | string[] | undefined;
+        resumeData?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+        forEachIndex?: number | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        forEachIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodUnknown> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const START_ASYNC_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/start-async";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId?: string | undefined;
+    } & {
+        resourceId?: string | undefined;
+        inputData?: unknown;
+        initialState?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
+        result?: unknown;
+        error?: unknown;
+        payload?: unknown;
+        initialState?: unknown;
+        steps?: Record<string, unknown> | undefined;
+        activeStepsPath?: Record<string, number[]> | undefined;
+        serializedStepGraph?: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[] | undefined;
     }>;
-    initialState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
-    serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>, "GET", "/workflows/:workflowId/runs/:runId">;
-export declare const DELETE_WORKFLOW_RUN_BY_ID_ROUTE: import("../server-adapter").ServerRoute<{
-    workflowId: string;
-    runId: string;
-}, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "DELETE", "/workflows/:workflowId/runs/:runId">;
-export declare const CREATE_WORKFLOW_RUN_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    disableScorers: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, {
-    runId: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    disableScorers: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/create-run">;
-export declare const STREAM_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    closeOnSuspend: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    closeOnSuspend: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, undefined>, "POST", "/workflows/:workflowId/stream">;
-export declare const RESUME_STREAM_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodUnknown>, "POST", "/workflows/:workflowId/resume-stream">;
-export declare const START_ASYNC_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, {
-    status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
-    result?: unknown;
-    error?: unknown;
-    payload?: unknown;
-    initialState?: unknown;
-    steps?: Record<string, unknown> | undefined;
-    activeStepsPath?: Record<string, number[]> | undefined;
-    serializedStepGraph?: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[] | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
-    }>>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
-    serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/start-async">;
-export declare const START_WORKFLOW_RUN_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/start">;
-export declare const OBSERVE_STREAM_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>, undefined>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>, undefined, z.ZodUnknown>, "POST", "/workflows/:workflowId/observe">;
-export declare const RESUME_ASYNC_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>, {
-    status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
-    result?: unknown;
-    error?: unknown;
-    payload?: unknown;
-    initialState?: unknown;
-    steps?: Record<string, unknown> | undefined;
-    activeStepsPath?: Record<string, number[]> | undefined;
-    serializedStepGraph?: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[] | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
-    }>>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
-    serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/resume-async">;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            running: "running";
+            waiting: "waiting";
+            suspended: "suspended";
+            failed: "failed";
+            canceled: "canceled";
+            pending: "pending";
+            bailed: "bailed";
+            tripwire: "tripwire";
+            paused: "paused";
+            skipped: "skipped";
+        }>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+        serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const START_WORKFLOW_RUN_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/start";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        resourceId?: string | undefined;
+        inputData?: unknown;
+        initialState?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const OBSERVE_STREAM_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/observe";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+        offset?: number | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+        offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>, undefined, z.ZodUnknown> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESUME_ASYNC_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/resume-async";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step?: string | string[] | undefined;
+        resumeData?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+        forEachIndex?: number | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
+        result?: unknown;
+        error?: unknown;
+        payload?: unknown;
+        initialState?: unknown;
+        steps?: Record<string, unknown> | undefined;
+        activeStepsPath?: Record<string, number[]> | undefined;
+        serializedStepGraph?: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[] | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        forEachIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            running: "running";
+            waiting: "waiting";
+            suspended: "suspended";
+            failed: "failed";
+            canceled: "canceled";
+            pending: "pending";
+            bailed: "bailed";
+            tripwire: "tripwire";
+            paused: "paused";
+            skipped: "skipped";
+        }>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+        serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 /**
  * Fire-and-forget resume: dispatches the resume and returns immediately with the runId,
  * without waiting for the workflow to complete. For Inngest-backed workflows this avoids
@@ -694,509 +939,766 @@ export declare const RESUME_ASYNC_WORKFLOW_ROUTE: import("../server-adapter").Se
  * kept separate in v1 to avoid a breaking change to the existing `resume-async` response
  * contract (which returns the full workflow result).
  */
-export declare const RESUME_NO_WAIT_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>, {
-    runId: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/resume-no-wait">;
-export declare const RESUME_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    forEachIndex: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/resume">;
-export declare const RESTART_ASYNC_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, {
-    status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
-    result?: unknown;
-    error?: unknown;
-    payload?: unknown;
-    initialState?: unknown;
-    steps?: Record<string, unknown> | undefined;
-    activeStepsPath?: Record<string, number[]> | undefined;
-    serializedStepGraph?: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[] | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
-    }>>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
-    serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/restart-async">;
-export declare const RESTART_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/restart">;
-export declare const RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE: import("../server-adapter").ServerRoute<{
-    workflowId: string;
-}, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/restart-all-active-workflow-runs-async">;
-export declare const RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE: import("../server-adapter").ServerRoute<{
-    workflowId: string;
-}, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/restart-all-active-workflow-runs">;
-export declare const TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
-    nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, {
-    status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
-    result?: unknown;
-    error?: unknown;
-    payload?: unknown;
-    initialState?: unknown;
-    steps?: Record<string, unknown> | undefined;
-    activeStepsPath?: Record<string, number[]> | undefined;
-    serializedStepGraph?: {
-        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
-    }[] | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
-    nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        running: "running";
-        waiting: "waiting";
-        suspended: "suspended";
-        failed: "failed";
-        canceled: "canceled";
-        pending: "pending";
-        bailed: "bailed";
-        tripwire: "tripwire";
-        paused: "paused";
-        skipped: "skipped";
-    }>>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
-    serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            step: "step";
-            agent: "agent";
-            tool: "tool";
-            mapping: "mapping";
-            sleep: "sleep";
-            sleepUntil: "sleepUntil";
-            waitForEvent: "waitForEvent";
-            parallel: "parallel";
-            conditional: "conditional";
-            loop: "loop";
-            foreach: "foreach";
-            workflow: "workflow";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/time-travel-async">;
-export declare const TIME_TRAVEL_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
-    nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
-    nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/time-travel">;
-export declare const TIME_TRAVEL_STREAM_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
-    nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
-    nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, undefined>, "POST", "/workflows/:workflowId/time-travel-stream">;
-export declare const CANCEL_WORKFLOW_RUN_ROUTE: import("../server-adapter").ServerRoute<{
-    workflowId: string;
-    runId: string;
-}, {
-    message: string;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>>, "POST", "/workflows/:workflowId/runs/:runId/cancel">;
-export declare const STREAM_LEGACY_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    closeOnSuspend: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    resourceId: z.ZodOptional<z.ZodString>;
-    inputData: z.ZodOptional<z.ZodUnknown>;
-    initialState: z.ZodOptional<z.ZodUnknown>;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    tracingOptions: z.ZodOptional<z.ZodObject<{
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        traceId: z.ZodOptional<z.ZodString>;
-        parentSpanId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hideInput: z.ZodOptional<z.ZodBoolean>;
-        hideOutput: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    closeOnSuspend: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodUnknown>, "POST", "/workflows/:workflowId/stream-legacy">;
-export declare const OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, undefined>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strip>, undefined, z.ZodUnknown>, "POST", "/workflows/:workflowId/observe-stream-legacy">;
-export declare const EXECUTE_WORKFLOW_STEP_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    workflowId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    stepId: z.ZodString;
-    executionPath: z.ZodArray<z.ZodNumber>;
-    stepResults: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    requestContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    retryCount: z.ZodOptional<z.ZodNumber>;
-    foreachIdx: z.ZodOptional<z.ZodNumber>;
-    format: z.ZodOptional<z.ZodEnum<{
-        legacy: "legacy";
-        vnext: "vnext";
-    }>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    validateInputs: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, unknown, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    workflowId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    stepId: z.ZodString;
-    executionPath: z.ZodArray<z.ZodNumber>;
-    stepResults: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    requestContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    resumeData: z.ZodOptional<z.ZodUnknown>;
-    retryCount: z.ZodOptional<z.ZodNumber>;
-    foreachIdx: z.ZodOptional<z.ZodNumber>;
-    format: z.ZodOptional<z.ZodEnum<{
-        legacy: "legacy";
-        vnext: "vnext";
-    }>>;
-    perStep: z.ZodOptional<z.ZodBoolean>;
-    validateInputs: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodUnknown>, "POST", "/workflows/:workflowId/runs/:runId/steps/execute">;
+export declare const RESUME_NO_WAIT_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/resume-no-wait";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step?: string | string[] | undefined;
+        resumeData?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+        forEachIndex?: number | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        runId: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        forEachIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESUME_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/resume";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step?: string | string[] | undefined;
+        resumeData?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+        forEachIndex?: number | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        step: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        forEachIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESTART_ASYNC_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/restart-async";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
+        result?: unknown;
+        error?: unknown;
+        payload?: unknown;
+        initialState?: unknown;
+        steps?: Record<string, unknown> | undefined;
+        activeStepsPath?: Record<string, number[]> | undefined;
+        serializedStepGraph?: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[] | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            running: "running";
+            waiting: "waiting";
+            suspended: "suspended";
+            failed: "failed";
+            canceled: "canceled";
+            pending: "pending";
+            bailed: "bailed";
+            tripwire: "tripwire";
+            paused: "paused";
+            skipped: "skipped";
+        }>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+        serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESTART_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/restart";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/restart-all-active-workflow-runs-async";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/restart-all-active-workflow-runs";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/time-travel-async";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step: string | string[];
+        inputData?: unknown;
+        resumeData?: unknown;
+        initialState?: unknown;
+        context?: import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown> | undefined;
+        nestedStepsContext?: Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>> | undefined;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        status?: "success" | "running" | "waiting" | "suspended" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped" | undefined;
+        result?: unknown;
+        error?: unknown;
+        payload?: unknown;
+        initialState?: unknown;
+        steps?: Record<string, unknown> | undefined;
+        activeStepsPath?: Record<string, number[]> | undefined;
+        serializedStepGraph?: {
+            type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
+        }[] | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
+        nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            running: "running";
+            waiting: "waiting";
+            suspended: "suspended";
+            failed: "failed";
+            canceled: "canceled";
+            pending: "pending";
+            bailed: "bailed";
+            tripwire: "tripwire";
+            paused: "paused";
+            skipped: "skipped";
+        }>>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        activeStepsPath: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+        serializedStepGraph: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                step: "step";
+                agent: "agent";
+                tool: "tool";
+                mapping: "mapping";
+                sleep: "sleep";
+                sleepUntil: "sleepUntil";
+                waitForEvent: "waitForEvent";
+                parallel: "parallel";
+                conditional: "conditional";
+                loop: "loop";
+                foreach: "foreach";
+                workflow: "workflow";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const TIME_TRAVEL_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/time-travel";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step: string | string[];
+        inputData?: unknown;
+        resumeData?: unknown;
+        initialState?: unknown;
+        context?: import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown> | undefined;
+        nestedStepsContext?: Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>> | undefined;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
+        nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const TIME_TRAVEL_STREAM_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/time-travel-stream";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        step: string | string[];
+        inputData?: unknown;
+        resumeData?: unknown;
+        initialState?: unknown;
+        context?: import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown> | undefined;
+        nestedStepsContext?: Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>> | undefined;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        step: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        context: z.ZodOptional<z.ZodType<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>, unknown>>>;
+        nestedStepsContext: z.ZodOptional<z.ZodType<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown, z.core.$ZodTypeInternals<Record<string, import("@mastra/core/workflows").TimeTravelContext<unknown, unknown, unknown, unknown>>, unknown>>>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, undefined> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const CANCEL_WORKFLOW_RUN_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/runs/:runId/cancel";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+        runId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        message: string;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+        runId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const STREAM_LEGACY_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/stream-legacy";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & {
+        resourceId?: string | undefined;
+        inputData?: unknown;
+        initialState?: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        perStep?: boolean | undefined;
+        closeOnSuspend?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        resourceId: z.ZodOptional<z.ZodString>;
+        inputData: z.ZodOptional<z.ZodUnknown>;
+        initialState: z.ZodOptional<z.ZodUnknown>;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            hideInput: z.ZodOptional<z.ZodBoolean>;
+            hideOutput: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        closeOnSuspend: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodUnknown> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/observe-stream-legacy";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+    } & {
+        runId: string;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+    }, z.core.$strip>, undefined, z.ZodUnknown> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const EXECUTE_WORKFLOW_STEP_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/:workflowId/runs/:runId/steps/execute";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        workflowId: string;
+        runId: string;
+    } & {
+        stepId: string;
+        executionPath: number[];
+        stepResults: Record<string, unknown>;
+        state: Record<string, unknown>;
+        requestContext: Record<string, unknown>;
+        input?: unknown;
+        resumeData?: unknown;
+        retryCount?: number | undefined;
+        foreachIdx?: number | undefined;
+        format?: "legacy" | "vnext" | undefined;
+        perStep?: boolean | undefined;
+        validateInputs?: boolean | undefined;
+    } & import("../server-adapter").ServerContext): Promise<unknown>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<z.ZodObject<{
+        workflowId: z.ZodString;
+        runId: z.ZodString;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        stepId: z.ZodString;
+        executionPath: z.ZodArray<z.ZodNumber>;
+        stepResults: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        requestContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        resumeData: z.ZodOptional<z.ZodUnknown>;
+        retryCount: z.ZodOptional<z.ZodNumber>;
+        foreachIdx: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodEnum<{
+            legacy: "legacy";
+            vnext: "vnext";
+        }>>;
+        perStep: z.ZodOptional<z.ZodBoolean>;
+        validateInputs: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodUnknown> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 /**
  * Generic push receive endpoint for workflow events. A push-mode broker
  * (GCP Pub/Sub push subscription, SNS, EventBridge) — or a per-broker adapter
@@ -1213,32 +1715,52 @@ export declare const EXECUTE_WORKFLOW_STEP_ROUTE: import("../server-adapter").Se
  * for GCP Pub/Sub push). Without an auth provider the endpoint is effectively
  * public — same caveat as `EXECUTE_WORKFLOW_STEP_ROUTE`.
  */
-export declare const RECEIVE_WORKFLOW_EVENT_ROUTE: import("../server-adapter").ServerRoute<{
-    event: {
-        [x: string]: unknown;
-        id: string;
-        type: string;
-        data: unknown;
-        runId: string;
-        createdAt: string;
-        index?: number | undefined;
-        deliveryAttempt?: number | undefined;
-    };
-}, {
-    ok: boolean;
-    retry?: boolean | undefined;
-}, "json", import("../server-adapter").RouteSchemas<undefined, undefined, z.ZodObject<{
-    event: z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodString;
-        data: z.ZodUnknown;
-        runId: z.ZodString;
-        createdAt: z.ZodString;
-        index: z.ZodOptional<z.ZodNumber>;
-        deliveryAttempt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$loose>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-    retry: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>>, "POST", "/workflows/events">;
+export declare const RECEIVE_WORKFLOW_EVENT_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/workflows/events";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        event: {
+            [x: string]: unknown;
+            id: string;
+            type: string;
+            data: unknown;
+            runId: string;
+            createdAt: string;
+            index?: number | undefined;
+            deliveryAttempt?: number | undefined;
+        };
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+        retry?: boolean | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<undefined, undefined, z.ZodObject<{
+        event: z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            data: z.ZodUnknown;
+            runId: z.ZodString;
+            createdAt: z.ZodString;
+            index: z.ZodOptional<z.ZodNumber>;
+            deliveryAttempt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+        retry: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 //# sourceMappingURL=workflows.d.ts.map