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

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,8 +599,12 @@ 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;
@@ -604,8 +612,8 @@ declare class Execution$1 extends jspb.Message {
 
     hasTriggerMark(): boolean;
     clearTriggerMark(): void;
-    getTriggerMark(): TriggerMark$1 | undefined;
-    setTriggerMark(value?: TriggerMark$1): Execution$1;
+    getTriggerMark(): TriggerMark | undefined;
+    setTriggerMark(value?: TriggerMark): 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,
+        triggerMark?: TriggerMark.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 TriggerMark extends jspb.Message { 
     getBlockNumber(): number;
-    setBlockNumber(value: number): TriggerMark$1;
+    setBlockNumber(value: number): TriggerMark;
     getLogIndex(): number;
-    setLogIndex(value: number): TriggerMark$1;
+    setLogIndex(value: number): TriggerMark;
     getTxHash(): string;
-    setTxHash(value: string): TriggerMark$1;
+    setTxHash(value: string): TriggerMark;
+    getEpoch(): number;
+    setEpoch(value: number): TriggerMark;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): TriggerMark$1.AsObject;
-    static toObject(includeInstance: boolean, msg: TriggerMark$1): TriggerMark$1.AsObject;
+    toObject(includeInstance?: boolean): TriggerMark.AsObject;
+    static toObject(includeInstance: boolean, msg: TriggerMark): TriggerMark.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: TriggerMark, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TriggerMark;
+    static deserializeBinaryFromReader(message: TriggerMark, reader: jspb.BinaryReader): TriggerMark;
 }
 
-declare namespace TriggerMark$1 {
+declare namespace TriggerMark {
     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;
+
+    hasTriggerMark(): boolean;
+    clearTriggerMark(): void;
+    getTriggerMark(): TriggerMark | undefined;
+    setTriggerMark(value?: TriggerMark): UserTriggerTaskReq;
+    getRunInline(): boolean;
+    setRunInline(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,
+        triggerMark?: TriggerMark.AsObject,
+        runInline: 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,9 +1428,10 @@ 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
@@ -1251,9 +1443,46 @@ declare class Workflow implements WorkflowProps {
      * @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 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"> & {
+    stepsList: Step[];
+};
+type TriggerMarkProps = TriggerMark.AsObject;
+declare class Execution implements ExecutionProps {
+    id: string;
+    startAt: number;
+    endAt: number;
+    success: boolean;
+    error: string;
+    triggerMark?: TriggerMarkProps;
+    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 +1590,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 +1600,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
@@ -1404,36 +1626,7 @@ interface GetKeyResponse {
 interface ClientOption {
     endpoint: string;
 }
-interface CreateTaskResponse {
-    id: string;
-}
-interface ListTasksResponse {
-    tasks: {
-        id: string;
-        status: string;
-    }[];
-}
-interface CancelTaskResponse {
-    value: boolean;
-}
-interface DeleteTaskResponse {
-    value: boolean;
-}
-interface SmartWallet {
-    address: string;
-    salt: string;
-    factory: string;
-}
-interface CreateWalletReq {
-    salt: string;
-    factoryAddress?: string;
-}
-interface TriggerMark {
-    blockNumber?: number;
-    logIndex?: number;
-    txHash?: string;
-    epoch?: number;
-}
+type SmartWallet = SmartWallet$1.AsObject;
 
 declare class BaseClient {
     readonly endpoint: string;
@@ -1448,14 +1641,74 @@ declare class BaseClient {
 }
 declare class Client extends BaseClient {
     constructor(config: ClientOption);
+    /**
+     * Get the list of smart wallets; new wallets can be added to the list by calling `addWallet`
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<SmartWallet[]>} - The list of SmartWallet objects
+     */
     getWallets(options: RequestOptions): Promise<SmartWallet[]>;
-    createWallet({ salt, factoryAddress }: CreateWalletReq, 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
+     * @param {RequestOptions} options - Request options
+     * @returns {Promise<SmartWallet>} - The added SmartWallet object
+     */
+    addWallet({ salt, factoryAddress }: GetWalletReq.AsObject, 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[]>;
+    /**
+     * 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, cursor: string, limit: number, options: RequestOptions): Promise<{
+        cursor: string;
+        result: Workflow[];
+    }>;
+    /**
+     * Get the list of executions for a workflow
+     * @param {string} workflowId - The Id of the workflow
+     * @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: Execution[] }>} - The list of Executions
+     */
+    getExecutions(workflowId: string, cursor: string, limit: number, options: RequestOptions): 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>;
+    triggerWorkflow(workflowId: string, triggerType: TriggerType, triggerMark: TriggerMark.AsObject, isBlocking: boolean | undefined, options: RequestOptions): Promise<UserTriggerTaskResp>;
+    /**
+     * 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, ETHTransferNode, type ETHTransferNodeProps, Edge, type EdgeProps, type Environment, EventTrigger, type EventTriggerProps, Execution, FixedTimeTrigger, type FixedTimeTriggerProps, type GetKeyResponse, 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 };