@avaprotocol/sdk-js 1.2.1-dev.3 → 1.2.1-dev.5

package/dist/index.d.mts

@@ -30,23 +30,23 @@ declare namespace IdReq {
     }
 }
 
-declare class FixedEpochCondition extends jspb.Message { 
+declare class FixedTimeCondition extends jspb.Message { 
     clearEpochsList(): void;
     getEpochsList(): Array<number>;
-    setEpochsList(value: Array<number>): FixedEpochCondition;
+    setEpochsList(value: Array<number>): FixedTimeCondition;
     addEpochs(value: number, index?: number): number;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): FixedEpochCondition.AsObject;
-    static toObject(includeInstance: boolean, msg: FixedEpochCondition): FixedEpochCondition.AsObject;
+    toObject(includeInstance?: boolean): FixedTimeCondition.AsObject;
+    static toObject(includeInstance: boolean, msg: FixedTimeCondition): FixedTimeCondition.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: FixedEpochCondition, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): FixedEpochCondition;
-    static deserializeBinaryFromReader(message: FixedEpochCondition, reader: jspb.BinaryReader): FixedEpochCondition;
+    static serializeBinaryToWriter(message: FixedTimeCondition, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FixedTimeCondition;
+    static deserializeBinaryFromReader(message: FixedTimeCondition, reader: jspb.BinaryReader): FixedTimeCondition;
 }
 
-declare namespace FixedEpochCondition {
+declare namespace FixedTimeCondition {
     export type AsObject = {
         epochsList: Array<number>,
     }
@@ -125,8 +125,8 @@ declare class TaskTrigger extends jspb.Message {
 
     hasFixedTime(): boolean;
     clearFixedTime(): void;
-    getFixedTime(): FixedEpochCondition | undefined;
-    setFixedTime(value?: FixedEpochCondition): TaskTrigger;
+    getFixedTime(): FixedTimeCondition | undefined;
+    setFixedTime(value?: FixedTimeCondition): TaskTrigger;
 
     hasCron(): boolean;
     clearCron(): void;
@@ -159,7 +159,7 @@ declare namespace TaskTrigger {
     export type AsObject = {
         name: string,
         manual: boolean,
-        fixedTime?: FixedEpochCondition.AsObject,
+        fixedTime?: FixedTimeCondition.AsObject,
         cron?: CronCondition.AsObject,
         block?: BlockCondition.AsObject,
         event?: EventCondition.AsObject,
@@ -232,6 +232,8 @@ declare class ContractReadNode$1 extends jspb.Message {
     setCallData(value: string): ContractReadNode$1;
     getContractAbi(): string;
     setContractAbi(value: string): ContractReadNode$1;
+    getMethod(): string;
+    setMethod(value: string): ContractReadNode$1;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): ContractReadNode$1.AsObject;
@@ -248,6 +250,7 @@ declare namespace ContractReadNode$1 {
         contractAddress: string,
         callData: string,
         contractAbi: string,
+        method: string,
     }
 }
 
@@ -303,6 +306,7 @@ declare class RestAPINode$1 extends jspb.Message {
 declare namespace RestAPINode$1 {
     export type AsObject = {
         url: string,
+
         headersMap: Array<[string, string]>,
         body: string,
         method: string,
@@ -522,10 +526,10 @@ declare class TaskNode extends jspb.Message {
     getContractRead(): ContractReadNode$1 | undefined;
     setContractRead(value?: ContractReadNode$1): TaskNode;
 
-    hasGraphqlDataQuery(): boolean;
-    clearGraphqlDataQuery(): void;
-    getGraphqlDataQuery(): GraphQLQueryNode$1 | undefined;
-    setGraphqlDataQuery(value?: GraphQLQueryNode$1): TaskNode;
+    hasGraphqlQuery(): boolean;
+    clearGraphqlQuery(): void;
+    getGraphqlQuery(): GraphQLQueryNode$1 | undefined;
+    setGraphqlQuery(value?: GraphQLQueryNode$1): TaskNode;
 
     hasRestApi(): boolean;
     clearRestApi(): void;
@@ -571,7 +575,7 @@ declare namespace TaskNode {
         ethTransfer?: ETHTransferNode$1.AsObject,
         contractWrite?: ContractWriteNode$1.AsObject,
         contractRead?: ContractReadNode$1.AsObject,
-        graphqlDataQuery?: GraphQLQueryNode$1.AsObject,
+        graphqlQuery?: GraphQLQueryNode$1.AsObject,
         restApi?: RestAPINode$1.AsObject,
         branch?: BranchNode$1.AsObject,
         filter?: FilterNode.AsObject,
@@ -584,7 +588,7 @@ declare namespace TaskNode {
         ETH_TRANSFER = 10,
         CONTRACT_WRITE = 11,
         CONTRACT_READ = 12,
-        GRAPHQL_DATA_QUERY = 13,
+        GRAPHQL_QUERY = 13,
         REST_API = 14,
         BRANCH = 15,
         FILTER = 16,
@@ -595,17 +599,21 @@ declare namespace TaskNode {
 }
 
 declare class Execution$1 extends jspb.Message { 
-    getEpoch(): number;
-    setEpoch(value: number): Execution$1;
+    getId(): string;
+    setId(value: string): Execution$1;
+    getStartAt(): number;
+    setStartAt(value: number): Execution$1;
+    getEndAt(): number;
+    setEndAt(value: number): Execution$1;
     getSuccess(): boolean;
     setSuccess(value: boolean): Execution$1;
     getError(): string;
     setError(value: string): Execution$1;
 
-    hasTriggerMark(): boolean;
-    clearTriggerMark(): void;
-    getTriggerMark(): TriggerMark$1 | undefined;
-    setTriggerMark(value?: TriggerMark$1): Execution$1;
+    hasTriggerMetadata(): boolean;
+    clearTriggerMetadata(): void;
+    getTriggerMetadata(): TriggerMetadata$1 | undefined;
+    setTriggerMetadata(value?: TriggerMetadata$1): Execution$1;
     getResult(): string;
     setResult(value: string): Execution$1;
     clearStepsList(): void;
@@ -625,10 +633,12 @@ declare class Execution$1 extends jspb.Message {
 
 declare namespace Execution$1 {
     export type AsObject = {
-        epoch: number,
+        id: string,
+        startAt: number,
+        endAt: number,
         success: boolean,
         error: string,
-        triggerMark?: TriggerMark$1.AsObject,
+        triggerMetadata?: TriggerMetadata$1.AsObject,
         result: string,
         stepsList: Array<Execution$1.Step.AsObject>,
     }
@@ -645,6 +655,10 @@ declare namespace Execution$1 {
         setLog(value: string): Step;
         getError(): string;
         setError(value: string): Step;
+        getStartAt(): number;
+        setStartAt(value: number): Step;
+        getEndAt(): number;
+        setEndAt(value: number): Step;
 
         serializeBinary(): Uint8Array;
         toObject(includeInstance?: boolean): Step.AsObject;
@@ -663,6 +677,8 @@ declare namespace Execution$1 {
             outputData: string,
             log: string,
             error: string,
+            startAt: number,
+            endAt: number,
         }
     }
 
@@ -685,6 +701,10 @@ declare class Task extends jspb.Message {
     setCompletedAt(value: number): Task;
     getMaxExecution(): number;
     setMaxExecution(value: number): Task;
+    getTotalExecution(): number;
+    setTotalExecution(value: number): Task;
+    getLastRanAt(): number;
+    setLastRanAt(value: number): Task;
     getStatus(): TaskStatus;
     setStatus(value: TaskStatus): Task;
 
@@ -700,10 +720,6 @@ declare class Task extends jspb.Message {
     getEdgesList(): Array<TaskEdge>;
     setEdgesList(value: Array<TaskEdge>): Task;
     addEdges(value?: TaskEdge, index?: number): TaskEdge;
-    clearExecutionsList(): void;
-    getExecutionsList(): Array<Execution$1>;
-    setExecutionsList(value: Array<Execution$1>): Task;
-    addExecutions(value?: Execution$1, index?: number): Execution$1;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): Task.AsObject;
@@ -725,11 +741,12 @@ declare namespace Task {
         memo: string,
         completedAt: number,
         maxExecution: number,
-        status: avs_pb.TaskStatus,
+        totalExecution: number,
+        lastRanAt: number,
+        status: TaskStatus,
         trigger?: TaskTrigger.AsObject,
         nodesList: Array<TaskNode.AsObject>,
         edgesList: Array<TaskEdge.AsObject>,
-        executionsList: Array<Execution$1.AsObject>,
     }
 }
 
@@ -891,10 +908,10 @@ declare namespace SmartWallet$1 {
 }
 
 declare class ListWalletResp extends jspb.Message { 
-    clearWalletsList(): void;
-    getWalletsList(): Array<SmartWallet$1>;
-    setWalletsList(value: Array<SmartWallet$1>): ListWalletResp;
-    addWallets(value?: SmartWallet$1, index?: number): SmartWallet$1;
+    clearItemsList(): void;
+    getItemsList(): Array<SmartWallet$1>;
+    setItemsList(value: Array<SmartWallet$1>): ListWalletResp;
+    addItems(value?: SmartWallet$1, index?: number): SmartWallet$1;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): ListWalletResp.AsObject;
@@ -908,13 +925,17 @@ declare class ListWalletResp extends jspb.Message {
 
 declare namespace ListWalletResp {
     export type AsObject = {
-        walletsList: Array<SmartWallet$1.AsObject>,
+        itemsList: Array<SmartWallet$1.AsObject>,
     }
 }
 
 declare class ListTasksReq extends jspb.Message { 
     getSmartWalletAddress(): string;
     setSmartWalletAddress(value: string): ListTasksReq;
+    getCursor(): string;
+    setCursor(value: string): ListTasksReq;
+    getItemPerPage(): number;
+    setItemPerPage(value: number): ListTasksReq;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): ListTasksReq.AsObject;
@@ -929,14 +950,18 @@ declare class ListTasksReq extends jspb.Message {
 declare namespace ListTasksReq {
     export type AsObject = {
         smartWalletAddress: string,
+        cursor: string,
+        itemPerPage: number,
     }
 }
 
 declare class ListTasksResp extends jspb.Message { 
-    clearTasksList(): void;
-    getTasksList(): Array<Task>;
-    setTasksList(value: Array<Task>): ListTasksResp;
-    addTasks(value?: Task, index?: number): Task;
+    clearItemsList(): void;
+    getItemsList(): Array<ListTasksResp.Item>;
+    setItemsList(value: Array<ListTasksResp.Item>): ListTasksResp;
+    addItems(value?: ListTasksResp.Item, index?: number): ListTasksResp.Item;
+    getCursor(): string;
+    setCursor(value: string): ListTasksResp;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): ListTasksResp.AsObject;
@@ -950,7 +975,117 @@ declare class ListTasksResp extends jspb.Message {
 
 declare namespace ListTasksResp {
     export type AsObject = {
-        tasksList: Array<Task.AsObject>,
+        itemsList: Array<ListTasksResp.Item.AsObject>,
+        cursor: string,
+    }
+
+
+    export class Item extends jspb.Message { 
+        getId(): string;
+        setId(value: string): Item;
+        getOwner(): string;
+        setOwner(value: string): Item;
+        getSmartWalletAddress(): string;
+        setSmartWalletAddress(value: string): Item;
+        getStartAt(): number;
+        setStartAt(value: number): Item;
+        getExpiredAt(): number;
+        setExpiredAt(value: number): Item;
+        getMemo(): string;
+        setMemo(value: string): Item;
+        getCompletedAt(): number;
+        setCompletedAt(value: number): Item;
+        getMaxExecution(): number;
+        setMaxExecution(value: number): Item;
+        getTotalExecution(): number;
+        setTotalExecution(value: number): Item;
+        getLastRanAt(): number;
+        setLastRanAt(value: number): Item;
+        getStatus(): TaskStatus;
+        setStatus(value: TaskStatus): Item;
+
+        hasTrigger(): boolean;
+        clearTrigger(): void;
+        getTrigger(): TaskTrigger | undefined;
+        setTrigger(value?: TaskTrigger): Item;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Item.AsObject;
+        static toObject(includeInstance: boolean, msg: Item): Item.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Item, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Item;
+        static deserializeBinaryFromReader(message: Item, reader: jspb.BinaryReader): Item;
+    }
+
+    export namespace Item {
+        export type AsObject = {
+            id: string,
+            owner: string,
+            smartWalletAddress: string,
+            startAt: number,
+            expiredAt: number,
+            memo: string,
+            completedAt: number,
+            maxExecution: number,
+            totalExecution: number,
+            lastRanAt: number,
+            status: TaskStatus,
+            trigger?: TaskTrigger.AsObject,
+        }
+    }
+
+}
+
+declare class ListExecutionsReq extends jspb.Message { 
+    getId(): string;
+    setId(value: string): ListExecutionsReq;
+    getCursor(): string;
+    setCursor(value: string): ListExecutionsReq;
+    getItemPerPage(): number;
+    setItemPerPage(value: number): ListExecutionsReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ListExecutionsReq.AsObject;
+    static toObject(includeInstance: boolean, msg: ListExecutionsReq): ListExecutionsReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ListExecutionsReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListExecutionsReq;
+    static deserializeBinaryFromReader(message: ListExecutionsReq, reader: jspb.BinaryReader): ListExecutionsReq;
+}
+
+declare namespace ListExecutionsReq {
+    export type AsObject = {
+        id: string,
+        cursor: string,
+        itemPerPage: number,
+    }
+}
+
+declare class ListExecutionsResp extends jspb.Message { 
+    clearItemsList(): void;
+    getItemsList(): Array<Execution$1>;
+    setItemsList(value: Array<Execution$1>): ListExecutionsResp;
+    addItems(value?: Execution$1, index?: number): Execution$1;
+    getCursor(): string;
+    setCursor(value: string): ListExecutionsResp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ListExecutionsResp.AsObject;
+    static toObject(includeInstance: boolean, msg: ListExecutionsResp): ListExecutionsResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ListExecutionsResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListExecutionsResp;
+    static deserializeBinaryFromReader(message: ListExecutionsResp, reader: jspb.BinaryReader): ListExecutionsResp;
+}
+
+declare namespace ListExecutionsResp {
+    export type AsObject = {
+        itemsList: Array<Execution$1.AsObject>,
+        cursor: string,
     }
 }
 
@@ -1000,74 +1135,77 @@ declare namespace KeyResp {
     }
 }
 
-declare class TriggerMark$1 extends jspb.Message { 
+declare class TriggerMetadata$1 extends jspb.Message { 
     getBlockNumber(): number;
-    setBlockNumber(value: number): TriggerMark$1;
+    setBlockNumber(value: number): TriggerMetadata$1;
     getLogIndex(): number;
-    setLogIndex(value: number): TriggerMark$1;
+    setLogIndex(value: number): TriggerMetadata$1;
     getTxHash(): string;
-    setTxHash(value: string): TriggerMark$1;
+    setTxHash(value: string): TriggerMetadata$1;
+    getEpoch(): number;
+    setEpoch(value: number): TriggerMetadata$1;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): TriggerMark$1.AsObject;
-    static toObject(includeInstance: boolean, msg: TriggerMark$1): TriggerMark$1.AsObject;
+    toObject(includeInstance?: boolean): TriggerMetadata$1.AsObject;
+    static toObject(includeInstance: boolean, msg: TriggerMetadata$1): TriggerMetadata$1.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: TriggerMark$1, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): TriggerMark$1;
-    static deserializeBinaryFromReader(message: TriggerMark$1, reader: jspb.BinaryReader): TriggerMark$1;
+    static serializeBinaryToWriter(message: TriggerMetadata$1, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TriggerMetadata$1;
+    static deserializeBinaryFromReader(message: TriggerMetadata$1, reader: jspb.BinaryReader): TriggerMetadata$1;
 }
 
-declare namespace TriggerMark$1 {
+declare namespace TriggerMetadata$1 {
     export type AsObject = {
         blockNumber: number,
         logIndex: number,
         txHash: string,
+        epoch: number,
     }
 }
 
-declare class CreateWalletReq$1 extends jspb.Message { 
+declare class GetWalletReq extends jspb.Message { 
     getSalt(): string;
-    setSalt(value: string): CreateWalletReq$1;
+    setSalt(value: string): GetWalletReq;
     getFactoryAddress(): string;
-    setFactoryAddress(value: string): CreateWalletReq$1;
+    setFactoryAddress(value: string): GetWalletReq;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): CreateWalletReq$1.AsObject;
-    static toObject(includeInstance: boolean, msg: CreateWalletReq$1): CreateWalletReq$1.AsObject;
+    toObject(includeInstance?: boolean): GetWalletReq.AsObject;
+    static toObject(includeInstance: boolean, msg: GetWalletReq): GetWalletReq.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: CreateWalletReq$1, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): CreateWalletReq$1;
-    static deserializeBinaryFromReader(message: CreateWalletReq$1, reader: jspb.BinaryReader): CreateWalletReq$1;
+    static serializeBinaryToWriter(message: GetWalletReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetWalletReq;
+    static deserializeBinaryFromReader(message: GetWalletReq, reader: jspb.BinaryReader): GetWalletReq;
 }
 
-declare namespace CreateWalletReq$1 {
+declare namespace GetWalletReq {
     export type AsObject = {
         salt: string,
         factoryAddress: string,
     }
 }
 
-declare class CreateWalletResp extends jspb.Message { 
+declare class GetWalletResp extends jspb.Message { 
     getAddress(): string;
-    setAddress(value: string): CreateWalletResp;
+    setAddress(value: string): GetWalletResp;
     getSalt(): string;
-    setSalt(value: string): CreateWalletResp;
+    setSalt(value: string): GetWalletResp;
     getFactoryAddress(): string;
-    setFactoryAddress(value: string): CreateWalletResp;
+    setFactoryAddress(value: string): GetWalletResp;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): CreateWalletResp.AsObject;
-    static toObject(includeInstance: boolean, msg: CreateWalletResp): CreateWalletResp.AsObject;
+    toObject(includeInstance?: boolean): GetWalletResp.AsObject;
+    static toObject(includeInstance: boolean, msg: GetWalletResp): GetWalletResp.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: CreateWalletResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): CreateWalletResp;
-    static deserializeBinaryFromReader(message: CreateWalletResp, reader: jspb.BinaryReader): CreateWalletResp;
+    static serializeBinaryToWriter(message: GetWalletResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetWalletResp;
+    static deserializeBinaryFromReader(message: GetWalletResp, reader: jspb.BinaryReader): GetWalletResp;
 }
 
-declare namespace CreateWalletResp {
+declare namespace GetWalletResp {
     export type AsObject = {
         address: string,
         salt: string,
@@ -1075,6 +1213,61 @@ declare namespace CreateWalletResp {
     }
 }
 
+declare class UserTriggerTaskReq extends jspb.Message { 
+    getTaskId(): string;
+    setTaskId(value: string): UserTriggerTaskReq;
+
+    hasTriggerMetadata(): boolean;
+    clearTriggerMetadata(): void;
+    getTriggerMetadata(): TriggerMetadata$1 | undefined;
+    setTriggerMetadata(value?: TriggerMetadata$1): UserTriggerTaskReq;
+    getIsBlocking(): boolean;
+    setIsBlocking(value: boolean): UserTriggerTaskReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UserTriggerTaskReq.AsObject;
+    static toObject(includeInstance: boolean, msg: UserTriggerTaskReq): UserTriggerTaskReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UserTriggerTaskReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UserTriggerTaskReq;
+    static deserializeBinaryFromReader(message: UserTriggerTaskReq, reader: jspb.BinaryReader): UserTriggerTaskReq;
+}
+
+declare namespace UserTriggerTaskReq {
+    export type AsObject = {
+        taskId: string,
+        triggerMetadata?: TriggerMetadata$1.AsObject,
+        isBlocking: boolean,
+    }
+}
+
+declare class UserTriggerTaskResp extends jspb.Message { 
+    getResult(): boolean;
+    setResult(value: boolean): UserTriggerTaskResp;
+    getExecutionId(): string;
+    setExecutionId(value: string): UserTriggerTaskResp;
+    getJobId(): string;
+    setJobId(value: string): UserTriggerTaskResp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UserTriggerTaskResp.AsObject;
+    static toObject(includeInstance: boolean, msg: UserTriggerTaskResp): UserTriggerTaskResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UserTriggerTaskResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UserTriggerTaskResp;
+    static deserializeBinaryFromReader(message: UserTriggerTaskResp, reader: jspb.BinaryReader): UserTriggerTaskResp;
+}
+
+declare namespace UserTriggerTaskResp {
+    export type AsObject = {
+        result: boolean,
+        executionId: string,
+        jobId: string,
+    }
+}
+
 declare enum TaskStatus {
     ACTIVE = 0,
     COMPLETED = 1,
@@ -1099,9 +1292,9 @@ interface IAggregatorClient {
     getNonce(request: NonceRequest, callback: (error: grpc.ServiceError | null, response: NonceResp) => void): grpc.ClientUnaryCall;
     getNonce(request: NonceRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: NonceResp) => void): grpc.ClientUnaryCall;
     getNonce(request: NonceRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: NonceResp) => void): grpc.ClientUnaryCall;
-    createWallet(request: CreateWalletReq$1, callback: (error: grpc.ServiceError | null, response: CreateWalletResp) => void): grpc.ClientUnaryCall;
-    createWallet(request: CreateWalletReq$1, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: CreateWalletResp) => void): grpc.ClientUnaryCall;
-    createWallet(request: CreateWalletReq$1, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: CreateWalletResp) => void): grpc.ClientUnaryCall;
+    getWallet(request: GetWalletReq, callback: (error: grpc.ServiceError | null, response: GetWalletResp) => void): grpc.ClientUnaryCall;
+    getWallet(request: GetWalletReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: GetWalletResp) => void): grpc.ClientUnaryCall;
+    getWallet(request: GetWalletReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: GetWalletResp) => void): grpc.ClientUnaryCall;
     listWallets(request: ListWalletReq, callback: (error: grpc.ServiceError | null, response: ListWalletResp) => void): grpc.ClientUnaryCall;
     listWallets(request: ListWalletReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: ListWalletResp) => void): grpc.ClientUnaryCall;
     listWallets(request: ListWalletReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: ListWalletResp) => void): grpc.ClientUnaryCall;
@@ -1114,12 +1307,18 @@ interface IAggregatorClient {
     getTask(request: IdReq, callback: (error: grpc.ServiceError | null, response: Task) => void): grpc.ClientUnaryCall;
     getTask(request: IdReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: Task) => void): grpc.ClientUnaryCall;
     getTask(request: IdReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: Task) => void): grpc.ClientUnaryCall;
+    listExecutions(request: ListExecutionsReq, callback: (error: grpc.ServiceError | null, response: ListExecutionsResp) => void): grpc.ClientUnaryCall;
+    listExecutions(request: ListExecutionsReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: ListExecutionsResp) => void): grpc.ClientUnaryCall;
+    listExecutions(request: ListExecutionsReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: ListExecutionsResp) => void): grpc.ClientUnaryCall;
     cancelTask(request: IdReq, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     cancelTask(request: IdReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     cancelTask(request: IdReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     deleteTask(request: IdReq, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     deleteTask(request: IdReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     deleteTask(request: IdReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
+    triggerTask(request: UserTriggerTaskReq, callback: (error: grpc.ServiceError | null, response: UserTriggerTaskResp) => void): grpc.ClientUnaryCall;
+    triggerTask(request: UserTriggerTaskReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: UserTriggerTaskResp) => void): grpc.ClientUnaryCall;
+    triggerTask(request: UserTriggerTaskReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: UserTriggerTaskResp) => void): grpc.ClientUnaryCall;
 }
 
 declare class AggregatorClient extends grpc.Client implements IAggregatorClient {
@@ -1130,9 +1329,9 @@ declare class AggregatorClient extends grpc.Client implements IAggregatorClient
     public getNonce(request: NonceRequest, callback: (error: grpc.ServiceError | null, response: NonceResp) => void): grpc.ClientUnaryCall;
     public getNonce(request: NonceRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: NonceResp) => void): grpc.ClientUnaryCall;
     public getNonce(request: NonceRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: NonceResp) => void): grpc.ClientUnaryCall;
-    public createWallet(request: CreateWalletReq$1, callback: (error: grpc.ServiceError | null, response: CreateWalletResp) => void): grpc.ClientUnaryCall;
-    public createWallet(request: CreateWalletReq$1, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: CreateWalletResp) => void): grpc.ClientUnaryCall;
-    public createWallet(request: CreateWalletReq$1, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: CreateWalletResp) => void): grpc.ClientUnaryCall;
+    public getWallet(request: GetWalletReq, callback: (error: grpc.ServiceError | null, response: GetWalletResp) => void): grpc.ClientUnaryCall;
+    public getWallet(request: GetWalletReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: GetWalletResp) => void): grpc.ClientUnaryCall;
+    public getWallet(request: GetWalletReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: GetWalletResp) => void): grpc.ClientUnaryCall;
     public listWallets(request: ListWalletReq, callback: (error: grpc.ServiceError | null, response: ListWalletResp) => void): grpc.ClientUnaryCall;
     public listWallets(request: ListWalletReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: ListWalletResp) => void): grpc.ClientUnaryCall;
     public listWallets(request: ListWalletReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: ListWalletResp) => void): grpc.ClientUnaryCall;
@@ -1145,27 +1344,18 @@ declare class AggregatorClient extends grpc.Client implements IAggregatorClient
     public getTask(request: IdReq, callback: (error: grpc.ServiceError | null, response: Task) => void): grpc.ClientUnaryCall;
     public getTask(request: IdReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: Task) => void): grpc.ClientUnaryCall;
     public getTask(request: IdReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: Task) => void): grpc.ClientUnaryCall;
+    public listExecutions(request: ListExecutionsReq, callback: (error: grpc.ServiceError | null, response: ListExecutionsResp) => void): grpc.ClientUnaryCall;
+    public listExecutions(request: ListExecutionsReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: ListExecutionsResp) => void): grpc.ClientUnaryCall;
+    public listExecutions(request: ListExecutionsReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: ListExecutionsResp) => void): grpc.ClientUnaryCall;
     public cancelTask(request: IdReq, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     public cancelTask(request: IdReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     public cancelTask(request: IdReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     public deleteTask(request: IdReq, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     public deleteTask(request: IdReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
     public deleteTask(request: IdReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_wrappers_pb.BoolValue) => void): grpc.ClientUnaryCall;
-}
-
-type ExecutionProps = Execution$1.AsObject;
-type TriggerMarkProps = TriggerMark$1.AsObject;
-type StepProps = Execution$1.Step.AsObject;
-declare class Execution implements ExecutionProps {
-    epoch: number;
-    success: boolean;
-    error: string;
-    triggerMark?: TriggerMarkProps;
-    result: string;
-    stepsList: Array<StepProps>;
-    constructor(props: ExecutionProps);
-    static fromResponse(execution: Execution$1): Execution;
-    toRequest(): Execution$1;
+    public triggerTask(request: UserTriggerTaskReq, callback: (error: grpc.ServiceError | null, response: UserTriggerTaskResp) => void): grpc.ClientUnaryCall;
+    public triggerTask(request: UserTriggerTaskReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: UserTriggerTaskResp) => void): grpc.ClientUnaryCall;
+    public triggerTask(request: UserTriggerTaskReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: UserTriggerTaskResp) => void): grpc.ClientUnaryCall;
 }
 
 declare const NodeTypes: typeof TaskNode.TaskTypeCase;
@@ -1196,7 +1386,7 @@ declare class Edge implements EdgeProps {
 
 declare const TriggerTypes: typeof TaskTrigger.TriggerTypeCase;
 type TriggerType = TaskTrigger.TriggerTypeCase;
-type TriggerData = FixedEpochCondition.AsObject | CronCondition.AsObject | BlockCondition.AsObject | EventCondition.AsObject | null;
+type TriggerData = FixedTimeCondition.AsObject | CronCondition.AsObject | BlockCondition.AsObject | EventCondition.AsObject | null;
 type TriggerProps = Omit<TaskTrigger.AsObject, "manual" | "fixedTime" | "cron" | "block" | "event"> & {
     type: TriggerType;
     data: TriggerData;
@@ -1215,7 +1405,7 @@ declare class Trigger implements TriggerProps {
 
 declare const WorkflowStatuses: typeof TaskStatus;
 type WorkflowStatus = TaskStatus;
-type WorkflowProps = Omit<Task.AsObject, "id" | "owner" | "completedAt" | "status" | "executionsList" | "memo" | "trigger" | "nodesList" | "edgesList"> & {
+type WorkflowProps = Omit<Task.AsObject, "id" | "owner" | "completedAt" | "status" | "executionsList" | "memo" | "trigger" | "nodesList" | "edgesList" | "totalExecution" | "lastRanAt"> & {
     id?: string;
     owner?: string;
     completedAt?: number;
@@ -1224,7 +1414,8 @@ type WorkflowProps = Omit<Task.AsObject, "id" | "owner" | "completedAt" | "statu
     trigger: Trigger;
     nodes: Node[];
     edges: Edge[];
-    executions?: Execution[];
+    totalExecution?: number;
+    lastRanAt?: number;
 };
 declare class Workflow implements WorkflowProps {
     smartWalletAddress: string;
@@ -1237,23 +1428,87 @@ declare class Workflow implements WorkflowProps {
     id?: string;
     owner?: string;
     memo?: string;
-    executions?: Execution[];
     completedAt?: number;
     status?: WorkflowStatus;
+    totalExecution?: number;
+    lastRanAt?: number;
     /**
      * Create an instance of Workflow from user inputs
      * @param props
      */
     constructor(props: WorkflowProps);
     /**
-     * Create an instance of Workflow from AVS getTask response
+     * Create an instance of Workflow from AVS getWorkflow response
      * @param res
      * @returns
      */
     static fromResponse(obj: Task): Workflow;
+    /**
+     * Create an instance of Workflow with only selected fields
+     * @param obj
+     */
+    static fromListResponse(obj: ListTasksResp.Item): Workflow;
     toRequest(): CreateTaskReq;
 }
 
+type TriggerMetadataProps = {
+    type: TaskTrigger.TriggerTypeCase.FIXED_TIME;
+    epoch: number;
+} | {
+    type: TaskTrigger.TriggerTypeCase.CRON;
+    epoch: number;
+} | {
+    type: TaskTrigger.TriggerTypeCase.BLOCK;
+    blockNumber: number;
+} | {
+    type: TaskTrigger.TriggerTypeCase.EVENT;
+    blockNumber: number;
+    logIndex: number;
+    txHash: string;
+};
+declare class TriggerMetadata {
+    type: TriggerType;
+    blockNumber?: number;
+    epoch?: number;
+    logIndex?: number;
+    txHash?: string;
+    constructor(props: TriggerMetadataProps);
+    static fromResponse(data: TriggerMetadata$1 | undefined): TriggerMetadata | undefined;
+    toRequest(): TriggerMetadata$1;
+}
+
+type StepProps = Execution$1.Step.AsObject;
+declare class Step implements StepProps {
+    nodeId: string;
+    success: boolean;
+    outputData: string;
+    log: string;
+    error: string;
+    startAt: number;
+    endAt: number;
+    constructor(props: StepProps);
+    static fromResponse(step: Execution$1.Step): Step;
+    toRequest(): Execution$1.Step;
+}
+
+type ExecutionProps = Omit<Execution$1.AsObject, "stepsList" | "triggerMetadata"> & {
+    stepsList: Step[];
+    triggerMetadata: TriggerMetadata | undefined;
+};
+declare class Execution implements ExecutionProps {
+    id: string;
+    startAt: number;
+    endAt: number;
+    success: boolean;
+    error: string;
+    triggerMetadata: TriggerMetadata | undefined;
+    result: string;
+    stepsList: Step[];
+    constructor(props: ExecutionProps);
+    static fromResponse(execution: Execution$1): Execution;
+    toRequest(): Execution$1;
+}
+
 type ContractWriteNodeData = ContractWriteNode$1.AsObject;
 type ContractWriteNodeProps = NodeProps & {
     data: ContractWriteNodeData;
@@ -1361,7 +1616,7 @@ declare class EventTrigger extends Trigger {
     static fromResponse(raw: TaskTrigger): EventTrigger;
 }
 
-type FixedTimeTriggerDataType = FixedEpochCondition.AsObject;
+type FixedTimeTriggerDataType = FixedTimeCondition.AsObject;
 type FixedTimeTriggerProps = TriggerProps & {
     data: FixedTimeTriggerDataType;
 };
@@ -1371,13 +1626,6 @@ declare class FixedTimeTrigger extends Trigger {
     static fromResponse(raw: TaskTrigger): FixedTimeTrigger;
 }
 
-type ManualTriggerProps = TriggerProps;
-declare class ManualTrigger extends Trigger {
-    constructor(props: ManualTriggerProps);
-    toRequest(): TaskTrigger;
-    static fromResponse(raw: TaskTrigger): ManualTrigger;
-}
-
 declare class TriggerFactory {
     /**
      * Static factory method to create Trigger instances
@@ -1386,7 +1634,7 @@ declare class TriggerFactory {
      */
     static create(props: TriggerProps): Trigger;
     /**
-     * Create an instance of Trigger from AVS getTask or listTasks response
+     * Create an instance of Trigger from AVS getWorkflow or getWorkflows response
      * @param trigger
      * @returns
      */
@@ -1395,67 +1643,173 @@ declare class TriggerFactory {
 
 type Environment = "production" | "development" | "staging";
 declare const AUTH_KEY_HEADER = "authkey";
+declare const DEFAULT_LIMIT = 10;
 interface RequestOptions {
-    authKey: string;
+    authKey?: string;
 }
-interface GetKeyResponse {
-    authKey: string;
+interface GetExecutionsRequest extends RequestOptions {
+    cursor?: string;
+    limit?: number;
 }
-interface ClientOption {
-    endpoint: string;
-}
-interface CreateTaskResponse {
-    id: string;
-}
-interface ListTasksResponse {
-    tasks: {
-        id: string;
-        status: string;
-    }[];
+interface GetWorkflowsRequest extends RequestOptions {
+    cursor?: string;
+    limit?: number;
 }
-interface CancelTaskResponse {
-    value: boolean;
-}
-interface DeleteTaskResponse {
-    value: boolean;
-}
-interface SmartWallet {
-    address: string;
-    salt: string;
-    factory: string;
+interface GetKeyResponse {
+    authKey: string;
 }
-interface CreateWalletReq {
+interface GetWalletRequest {
     salt: string;
     factoryAddress?: string;
 }
-interface TriggerMark {
-    blockNumber?: number;
-    logIndex?: number;
-    txHash?: string;
-    epoch?: number;
+interface ClientOption {
+    endpoint: string;
+    factoryAddress?: string;
 }
+type SmartWallet = SmartWallet$1.AsObject;
 
 declare class BaseClient {
     readonly endpoint: string;
     readonly rpcClient: AggregatorClient;
     protected metadata: Metadata;
+    protected factoryAddress?: string;
+    protected authKey?: string;
     constructor(opts: ClientOption);
+    /**
+     * Check if the auth key is valid by decoding the JWT token and checking the expiration
+     * @param key - The auth key
+     * @returns {boolean} - Whether the auth key is valid
+     */
     isAuthKeyValid(key: string): boolean;
+    /**
+     * The API key could retrieve a wallet’s authKey by skipping its signature verification
+     * @param address - The address of the EOA wallet
+     * @param apiKey - The API key
+     * @param expiredAtEpoch - The expiration epoch
+     * @returns {Promise<GetKeyResponse>} - The response from the auth call
+     */
     authWithAPIKey(address: string, apiKey: string, expiredAtEpoch: number): Promise<GetKeyResponse>;
+    /**
+     * Getting an authKey from the server by verifying the signature of an EOA wallet
+     * @param address - The address of the EOA wallet
+     * @param signature - The signature of the EOA wallet
+     * @param expiredAtEpoch - The expiration epoch
+     * @returns {Promise<GetKeyResponse>} - The response from the auth call
+     */
     authWithSignature(address: string, signature: string, expiredAtEpoch: number): Promise<GetKeyResponse>;
-    protected _callRPC<TResponse, TRequest>(method: string, request: TRequest | any, options?: RequestOptions): Promise<TResponse>;
-    protected _callAnonRPC<TResponse, TRequest>(method: string, request: TRequest | any, options?: RequestOptions): Promise<TResponse>;
+    /**
+     * The client could choose to store the authKey and use it for all requests; setting it to undefined will unset the authKey
+     * The authKey can be overridden at the request level by request options
+     * @param authKey - The auth key
+     */
+    setAuthKey(authKey: string | undefined): void;
+    /**
+     * Get the auth key if it’s set in the client
+     * @returns {string | undefined} - The auth key
+     */
+    getAuthKey(): string | undefined;
+    /**
+     * Set the factory address of smart wallets for the client
+     * @param address - The factory address
+     */
+    setFactoryAddress(address: string): void;
+    /**
+     * Get the factory address if it’s set in the client
+     * @returns {string | undefined} - The factory address
+     */
+    getFactoryAddress(): string | undefined;
+    /**
+     * Send a gRPC request with an auth key
+     * @param method - The method name
+     * @param request - The request message
+     * @param options - The request options
+     * @returns {Promise<TResponse>} - The response from the gRPC call
+     */
+    protected sendGrpcRequest<TResponse, TRequest>(method: string, request: TRequest | any, options?: RequestOptions): Promise<TResponse>;
 }
 declare class Client extends BaseClient {
     constructor(config: ClientOption);
-    getWallets(options: RequestOptions): Promise<SmartWallet[]>;
-    createWallet({ salt, factoryAddress }: CreateWalletReq, options: RequestOptions): Promise<SmartWallet>;
-    submitWorkflow(workflow: Workflow, options: RequestOptions): Promise<string>;
+    /**
+     * Get the list of smart wallets; new wallets can be added to the list by calling `getWallet`
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<SmartWallet[]>} - The list of SmartWallet objects
+     */
+    getWallets(options?: RequestOptions): Promise<SmartWallet[]>;
+    /**
+     * Add a new smart wallet address to the wallet list
+     * @param {string} salt - The salt for the wallet
+     * @param {string} factoryAddress - Factory address for the wallet; if not provided, the address stored in the client will be used
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<SmartWallet>} - The added SmartWallet object
+     */
+    getWallet({ salt, factoryAddress }: GetWalletRequest, options?: RequestOptions): Promise<SmartWallet>;
+    /**
+     * Submit a workflow to the AVS server; once the workflow is submitted, it cannot be modified
+     * @param {Workflow} workflow - Workflow object to submit
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<string>} - The Id of the submitted workflow
+     */
+    submitWorkflow(workflow: Workflow, options?: RequestOptions): Promise<string>;
     createWorkflow(props: WorkflowProps): Workflow;
-    getWorkflows(address: string, options: RequestOptions): Promise<Workflow[]>;
-    getWorkflow(id: string, options: RequestOptions): Promise<Workflow>;
-    cancelWorkflow(id: string, options: RequestOptions): Promise<boolean>;
-    deleteWorkflow(id: string, options: RequestOptions): Promise<boolean>;
+    /**
+     * Get the list of workflows; new workflows can be created by calling `submitWorkflow`
+     * @param {string} address - The address of the smart wallet
+     * @param {string} cursor - The cursor for the list
+     * @param {number} limit - The limit for the list
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<{ cursor: string; result: Workflow[] }>} - The list of Workflow objects
+     */
+    getWorkflows(address: string, options?: GetWorkflowsRequest): Promise<{
+        cursor: string;
+        result: Workflow[];
+    }>;
+    /**
+     * Get the list of executions for a workflow
+     * @param {string} workflowId - The Id of the workflow
+     * @param {GetExecutionsRequest} options - Request options
+     * @param {string} [options.cursor] - The cursor for pagination
+     * @param {number} [options.limit] - The page limit of the response; default is 10
+     * @param {string} [options.authKey] - The auth key for the request
+     * @returns {Promise<{ cursor: string; result: Execution[] }>} - The list of Executions
+     */
+    getExecutions(workflowId: string, options?: GetExecutionsRequest): Promise<{
+        cursor: string;
+        result: Execution[];
+    }>;
+    /**
+     * Get a workflow by its Id
+     * @param {string} id - The Id of the workflow
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<Workflow>} - The Workflow object
+     */
+    getWorkflow(id: string, options?: RequestOptions): Promise<Workflow>;
+    /**
+     * Manually trigger a workflow by its Id, and manual trigger data input
+     * @param id - The Id of the workflow
+     * @param triggerData - The data of the trigger
+     * @param isBlocking - Whether the trigger is blocking
+     * @param options - Request options
+     * @returns {Promise<avs_pb.UserTriggerTaskResp>} - The response from the trigger workflow call
+     */
+    triggerWorkflow({ id, data, isBlocking, }: {
+        id: string;
+        data: TriggerMetadataProps;
+        isBlocking: boolean;
+    }, options?: RequestOptions): Promise<UserTriggerTaskResp.AsObject>;
+    /**
+     * Cancel a workflow by its Id
+     * @param {string} id - The Id of the workflow
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<boolean>} - Whether the workflow was successfully canceled
+     */
+    cancelWorkflow(id: string, options?: RequestOptions): Promise<boolean>;
+    /**
+     * Delete a workflow by its Id
+     * @param {string} id - The Id of the workflow
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<boolean>} - Whether the workflow was successfully deleted
+     */
+    deleteWorkflow(id: string, options?: RequestOptions): Promise<boolean>;
 }
 
-export { AUTH_KEY_HEADER, BlockTrigger, type BlockTriggerProps, BranchNode, type BranchNodeData, type BranchNodeProps, type CancelTaskResponse, type ClientOption, ContractReadNode, type ContractReadNodeProps, ContractWriteNode, type ContractWriteNodeProps, type CreateTaskResponse, type CreateWalletReq, CronTrigger, type CronTriggerProps, CustomCodeLangs, CustomCodeNode, type CustomCodeNodeProps, type DeleteTaskResponse, ETHTransferNode, type ETHTransferNodeProps, Edge, type EdgeProps, type Environment, EventTrigger, type EventTriggerProps, Execution, FixedTimeTrigger, type FixedTimeTriggerProps, type GetKeyResponse, GraphQLQueryNode, type GraphQLQueryNodeProps, type ListTasksResponse, ManualTrigger, type ManualTriggerProps, Node, NodeFactory, type NodeType, NodeTypes, type RequestOptions, RestAPINode, type RestAPINodeProps, type SmartWallet, Trigger, TriggerFactory, type TriggerMark, type TriggerProps, type TriggerType, TriggerTypes, Workflow, type WorkflowProps, type WorkflowStatus, WorkflowStatuses, Client as default, getKeyRequestMessage };
+export { AUTH_KEY_HEADER, BlockTrigger, type BlockTriggerProps, BranchNode, type BranchNodeData, type BranchNodeProps, type ClientOption, ContractReadNode, type ContractReadNodeProps, ContractWriteNode, type ContractWriteNodeProps, CronTrigger, type CronTriggerProps, CustomCodeLangs, CustomCodeNode, type CustomCodeNodeProps, DEFAULT_LIMIT, ETHTransferNode, type ETHTransferNodeProps, Edge, type EdgeProps, type Environment, EventTrigger, type EventTriggerProps, Execution, FixedTimeTrigger, type FixedTimeTriggerProps, type GetExecutionsRequest, type GetKeyResponse, type GetWalletRequest, type GetWorkflowsRequest, GraphQLQueryNode, type GraphQLQueryNodeProps, Node, NodeFactory, type NodeProps, type NodeType, NodeTypes, type RequestOptions, RestAPINode, type RestAPINodeProps, type SmartWallet, Trigger, TriggerFactory, type TriggerProps, type TriggerType, TriggerTypes, Workflow, type WorkflowProps, type WorkflowStatus, WorkflowStatuses, Client as default, getKeyRequestMessage };