@mastra/libsql 0.11.0-alpha.3 → 0.11.1-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/libsql@0.11.0-alpha.3 build /home/runner/work/mastra/mastra/stores/libsql
+> @mastra/libsql@0.11.1-alpha.0 build /home/runner/work/mastra/mastra/stores/libsql
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 12207ms
+TSC ⚡️ Build success in 11368ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 13745ms
+DTS ⚡️ Build success in 13487ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 72.42 KB
-ESM ⚡️ Build success in 2002ms
-CJS dist/index.cjs 73.39 KB
-CJS ⚡️ Build success in 2005ms
+ESM dist/index.js 87.14 KB
+ESM ⚡️ Build success in 2070ms
+CJS dist/index.cjs 88.20 KB
+CJS ⚡️ Build success in 2070ms

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # @mastra/libsql
 
+## 0.11.1-alpha.0
+
+### Patch Changes
+
+- 7ba91fa: Throw mastra errors methods not implemented yet
+- da168a4: increase the peer deps range
+- Updated dependencies [f248d53]
+- Updated dependencies [2affc57]
+- Updated dependencies [66e13e3]
+- Updated dependencies [edd9482]
+- Updated dependencies [18344d7]
+- Updated dependencies [9d372c2]
+- Updated dependencies [40c2525]
+- Updated dependencies [e473f27]
+- Updated dependencies [032cb66]
+- Updated dependencies [703ac71]
+- Updated dependencies [a723d69]
+- Updated dependencies [5889a31]
+- Updated dependencies [65e3395]
+- Updated dependencies [4933192]
+- Updated dependencies [d1c77a4]
+- Updated dependencies [bea9dd1]
+- Updated dependencies [dcd4802]
+- Updated dependencies [7ba91fa]
+  - @mastra/core@0.11.0-alpha.2
+
+## 0.11.0
+
+### Minor Changes
+
+- 8a3bfd2: Update peerdeps to latest core
+
+### Patch Changes
+
+- 15e9d26: Added per-resource working memory for LibSQL, Upstash, and PG
+- d8f2d19: Add updateMessages API to storage classes (only support for PG and LibSQL for now) and to memory class. Additionally allow for metadata to be saved in the content field of a message.
+- 0fb9d64: [MASTRA-4018] Update saveMessages in storage adapters to upsert messages
+- 2097952: [MASTRA-4021] Fix PG getMessages and update messageLimit for all storage adapters
+- 144eb0b: [MASTRA-3669] Metadata Filter Types
+- f0150c4: Fix LibSQLStore and PgStore getMessagesPaginated implementation
+- 0e17048: Throw mastra errors in storage packages
+- Updated dependencies [15e9d26]
+- Updated dependencies [d1baedb]
+- Updated dependencies [d8f2d19]
+- Updated dependencies [4d21bf2]
+- Updated dependencies [07d6d88]
+- Updated dependencies [9d52b17]
+- Updated dependencies [2097952]
+- Updated dependencies [792c4c0]
+- Updated dependencies [5d74aab]
+- Updated dependencies [a8b194f]
+- Updated dependencies [4fb0cc2]
+- Updated dependencies [d2a7a31]
+- Updated dependencies [502fe05]
+- Updated dependencies [144eb0b]
+- Updated dependencies [8ba1b51]
+- Updated dependencies [4efcfa0]
+- Updated dependencies [0e17048]
+  - @mastra/core@0.10.7
+
 ## 0.11.0-alpha.3
 
 ### Minor Changes

package/LICENSE.md

@@ -1,7 +1,15 @@
-Copyright 2025 Mastra AI, Inc.
+# Apache License 2.0
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Copyright (c) 2025 Kepler Software, Inc.
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/_tsup-dts-rollup.d.cts

@@ -1,42 +1,81 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { Client } from '@libsql/client';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
+import type { IMastraLogger } from '@mastra/core/logger';
 import type { IndexStats } from '@mastra/core/vector';
 import type { InValue } from '@libsql/client';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/agent';
+import type { MastraMessageV2 as MastraMessageV2_2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import { MemoryStorage } from '@mastra/core/storage';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
 import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { ScoresStorage } from '@mastra/core/storage';
 import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageDomains } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
+import type { StorageGetTracesPaginatedArg } from '@mastra/core/storage';
+import type { StoragePagination } from '@mastra/core/storage';
 import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
+import { TracesStorage } from '@mastra/core/storage';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRun as WorkflowRun_2 } from '@mastra/core';
 import type { WorkflowRuns } from '@mastra/core/storage';
+import type { WorkflowRuns as WorkflowRuns_2 } from '@mastra/core';
+import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { WorkflowRunState as WorkflowRunState_2 } from '@mastra/core';
+import { WorkflowsStorage } from '@mastra/core/storage';
 
 export declare function buildFilterQuery(filter: LibSQLVectorFilter): FilterResult;
 
+export declare function createExecuteWriteOperationWithRetry({ logger, maxRetries, initialBackoffMs, }: {
+    logger: IMastraLogger;
+    maxRetries: number;
+    initialBackoffMs: number;
+}): <T>(operationFn: () => Promise<T>, operationDescription: string) => Promise<T>;
+
 declare interface FilterResult {
     sql: string;
     values: InValue[];
 }
 
+export declare class LegacyEvalsLibSQL extends LegacyEvalsStorage {
+    private client;
+    constructor({ client }: {
+        client: Client;
+    });
+    /** @deprecated use getEvals instead */
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
 /**
  * Vector store specific prompt that details supported operators and examples.
  * This prompt helps users construct valid filters for LibSQL Vector.
@@ -45,7 +84,7 @@ declare const LIBSQL_PROMPT = "When querying LibSQL Vector, you can ONLY use the
 export { LIBSQL_PROMPT }
 export { LIBSQL_PROMPT as LIBSQL_PROMPT_alias_1 }
 
-declare interface LibSQLConfig {
+declare type LibSQLConfig = {
     url: string;
     authToken?: string;
     /**
@@ -59,7 +98,11 @@ declare interface LibSQLConfig {
      * @default 100
      */
     initialBackoffMs?: number;
-}
+} | {
+    client: Client;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+};
 export { LibSQLConfig }
 export { LibSQLConfig as LibSQLConfig_alias_1 }
 
@@ -97,17 +140,18 @@ declare class LibSQLStore extends MastraStorage {
     private client;
     private readonly maxRetries;
     private readonly initialBackoffMs;
+    stores: StorageDomains;
     constructor(config: LibSQLConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
         resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
     };
-    private getCreateTableSQL;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
-    protected getSqlType(type: StorageColumn['type']): string;
     /**
      * Alters table schema to add columns if they don't exist
      * @param tableName Name of the table
@@ -122,18 +166,17 @@ declare class LibSQLStore extends MastraStorage {
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
-    private prepareStatement;
-    private executeWriteOperationWithRetry;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
     insert(args: {
         tableName: TABLE_NAMES;
         record: Record<string, any>;
     }): Promise<void>;
-    private doInsert;
     batchInsert(args: {
         tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    private doBatchInsert;
     load<R>({ tableName, keys }: {
         tableName: TABLE_NAMES;
         keys: Record<string, string>;
@@ -149,7 +192,9 @@ declare class LibSQLStore extends MastraStorage {
     }): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
-    } & PaginationArgs): Promise<PaginationInfo & {
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -163,8 +208,6 @@ declare class LibSQLStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    private parseRow;
-    private _getIncludedMessages;
     /**
      * @deprecated use getMessagesPaginated instead for paginated results.
      */
@@ -196,7 +239,6 @@ declare class LibSQLStore extends MastraStorage {
             };
         })[];
     }): Promise<MastraMessageV2[]>;
-    private transformEvalRow;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     getEvals(options?: {
@@ -205,27 +247,61 @@ declare class LibSQLStore extends MastraStorage {
     } & PaginationArgs): Promise<PaginationInfo & {
         evals: EvalRow[];
     }>;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByScorerId({ scorerId, entityId, entityType, pagination, }: {
+        scorerId: string;
+        entityId?: string;
+        entityType?: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    /**
+     * TRACES
+     */
     /**
      * @deprecated use getTracesPaginated instead.
      */
-    getTraces(args: {
-        name?: string;
-        scope?: string;
-        page: number;
-        perPage: number;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-        fromDate?: Date;
-        toDate?: Date;
-    }): Promise<Trace[]>;
-    getTracesPaginated(args: {
-        name?: string;
-        scope?: string;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-    } & PaginationArgs): Promise<PaginationInfo & {
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesArg): Promise<PaginationInfo & {
         traces: Trace[];
     }>;
+    batchTraceInsert(args: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+    /**
+     * WORKFLOWS
+     */
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
     getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         workflowName?: string;
         fromDate?: Date;
@@ -249,8 +325,6 @@ declare class LibSQLStore extends MastraStorage {
         workingMemory?: string;
         metadata?: Record<string, unknown>;
     }): Promise<StorageResourceType>;
-    private hasColumn;
-    private parseWorkflowRun;
 }
 export { LibSQLStore as DefaultStorage }
 export { LibSQLStore as DefaultStorage_alias_1 }
@@ -329,4 +403,236 @@ export { LibSQLVectorConfig as LibSQLVectorConfig_alias_1 }
 
 export declare type LibSQLVectorFilter = VectorFilter<keyof LibSQLOperatorValueMap, LibSQLOperatorValueMap>;
 
+export declare class MemoryLibSQL extends MemoryStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Client;
+        operations: StoreOperationsLibSQL;
+    });
+    private parseRow;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead for paginated results.
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2_2[];
+    }>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2_2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2_2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2_2[]>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    /**
+     * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+     */
+    getThreadsByResourceId(args: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+}
+
+export declare function prepareStatement({ tableName, record }: {
+    tableName: TABLE_NAMES;
+    record: Record<string, any>;
+}): {
+    sql: string;
+    args: InValue[];
+};
+
+export declare class ScoresLibSQL extends ScoresStorage {
+    private operations;
+    private client;
+    constructor({ client, operations }: {
+        client: Client;
+        operations: StoreOperationsLibSQL;
+    });
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByScorerId({ scorerId, entityId, entityType, pagination, }: {
+        scorerId: string;
+        entityId?: string;
+        entityType?: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    private transformScoreRow;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+}
+
+export declare class StoreOperationsLibSQL extends StoreOperations {
+    private client;
+    /**
+     * Maximum number of retries for write operations if an SQLITE_BUSY error occurs.
+     * @default 5
+     */
+    maxRetries: number;
+    /**
+     * Initial backoff time in milliseconds for retrying write operations on SQLITE_BUSY.
+     * The backoff time will double with each retry (exponential backoff).
+     * @default 100
+     */
+    initialBackoffMs: number;
+    constructor({ client, maxRetries, initialBackoffMs, }: {
+        client: Client;
+        maxRetries?: number;
+        initialBackoffMs?: number;
+    });
+    hasColumn(table: string, column: string): Promise<boolean>;
+    private getCreateTableSQL;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    private doInsert;
+    insert(args: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    private doBatchInsert;
+    batchInsert(args: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    /**
+     * Alters table schema to add columns if they don't exist
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+}
+
+export declare class TracesLibSQL extends TracesStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Client;
+        operations: StoreOperationsLibSQL;
+    });
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare class WorkflowsLibSQL extends WorkflowsStorage {
+    operations: StoreOperationsLibSQL;
+    client: Client;
+    constructor({ operations, client }: {
+        operations: StoreOperationsLibSQL;
+        client: Client;
+    });
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState_2;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState_2 | null>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun_2 | null>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns_2>;
+}
+
 export { }