echofi-client/dist/generated/task/task_pb.d.ts

A comprehensive TypeScript/JavaScript client library for EchoFi services with automatic gRPC-Web code generation, unified service access, and real-time WebSocket communication.

import * as jspb from 'google-protobuf'



export class Task extends jspb.Message {
  getId(): string;
  setId(value: string): Task;

  getName(): string;
  setName(value: string): Task;

  getDescription(): string;
  setDescription(value: string): Task;

  getTaskType(): TaskType;
  setTaskType(value: TaskType): Task;

  getVerificationType(): TaskVerificationType;
  setVerificationType(value: TaskVerificationType): Task;

  getTotalItems(): number;
  setTotalItems(value: number): Task;
  hasTotalItems(): boolean;
  clearTotalItems(): Task;

  getItemType(): string;
  setItemType(value: string): Task;
  hasItemType(): boolean;
  clearItemType(): Task;

  getRewardPoints(): number;
  setRewardPoints(value: number): Task;

  getExpirationHours(): number;
  setExpirationHours(value: number): Task;
  hasExpirationHours(): boolean;
  clearExpirationHours(): Task;

  getIsActive(): boolean;
  setIsActive(value: boolean): Task;

  getCreatedAt(): number;
  setCreatedAt(value: number): Task;

  getUpdatedAt(): number;
  setUpdatedAt(value: number): Task;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Task.AsObject;
  static toObject(includeInstance: boolean, msg: Task): Task.AsObject;
  static serializeBinaryToWriter(message: Task, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Task;
  static deserializeBinaryFromReader(message: Task, reader: jspb.BinaryReader): Task;
}

export namespace Task {
  export type AsObject = {
    id: string,
    name: string,
    description: string,
    taskType: TaskType,
    verificationType: TaskVerificationType,
    totalItems?: number,
    itemType?: string,
    rewardPoints: number,
    expirationHours?: number,
    isActive: boolean,
    createdAt: number,
    updatedAt: number,
  }

  export enum TotalItemsCase { 
    _TOTAL_ITEMS_NOT_SET = 0,
    TOTAL_ITEMS = 6,
  }

  export enum ItemTypeCase { 
    _ITEM_TYPE_NOT_SET = 0,
    ITEM_TYPE = 7,
  }

  export enum ExpirationHoursCase { 
    _EXPIRATION_HOURS_NOT_SET = 0,
    EXPIRATION_HOURS = 9,
  }
}

export class UserTask extends jspb.Message {
  getId(): number;
  setId(value: number): UserTask;

  getUserId(): string;
  setUserId(value: string): UserTask;

  getTaskId(): string;
  setTaskId(value: string): UserTask;

  getCurrentItems(): number;
  setCurrentItems(value: number): UserTask;

  getIsCompleted(): boolean;
  setIsCompleted(value: boolean): UserTask;

  getIsClaimed(): boolean;
  setIsClaimed(value: boolean): UserTask;

  getCompletedAt(): number;
  setCompletedAt(value: number): UserTask;

  getClaimedAt(): number;
  setClaimedAt(value: number): UserTask;

  getExpiresAt(): number;
  setExpiresAt(value: number): UserTask;

  getCreatedAt(): number;
  setCreatedAt(value: number): UserTask;

  getUpdatedAt(): number;
  setUpdatedAt(value: number): UserTask;

  getTask(): Task | undefined;
  setTask(value?: Task): UserTask;
  hasTask(): boolean;
  clearTask(): UserTask;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UserTask.AsObject;
  static toObject(includeInstance: boolean, msg: UserTask): UserTask.AsObject;
  static serializeBinaryToWriter(message: UserTask, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UserTask;
  static deserializeBinaryFromReader(message: UserTask, reader: jspb.BinaryReader): UserTask;
}

export namespace UserTask {
  export type AsObject = {
    id: number,
    userId: string,
    taskId: string,
    currentItems: number,
    isCompleted: boolean,
    isClaimed: boolean,
    completedAt: number,
    claimedAt: number,
    expiresAt: number,
    createdAt: number,
    updatedAt: number,
    task?: Task.AsObject,
  }

  export enum TaskCase { 
    _TASK_NOT_SET = 0,
    TASK = 12,
  }
}

export class TaskWithUserProgress extends jspb.Message {
  getTask(): Task | undefined;
  setTask(value?: Task): TaskWithUserProgress;
  hasTask(): boolean;
  clearTask(): TaskWithUserProgress;

  getUserTask(): UserTask | undefined;
  setUserTask(value?: UserTask): TaskWithUserProgress;
  hasUserTask(): boolean;
  clearUserTask(): TaskWithUserProgress;

  getCanBeClaimed(): boolean;
  setCanBeClaimed(value: boolean): TaskWithUserProgress;

  getIsExpired(): boolean;
  setIsExpired(value: boolean): TaskWithUserProgress;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TaskWithUserProgress.AsObject;
  static toObject(includeInstance: boolean, msg: TaskWithUserProgress): TaskWithUserProgress.AsObject;
  static serializeBinaryToWriter(message: TaskWithUserProgress, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TaskWithUserProgress;
  static deserializeBinaryFromReader(message: TaskWithUserProgress, reader: jspb.BinaryReader): TaskWithUserProgress;
}

export namespace TaskWithUserProgress {
  export type AsObject = {
    task?: Task.AsObject,
    userTask?: UserTask.AsObject,
    canBeClaimed: boolean,
    isExpired: boolean,
  }

  export enum UserTaskCase { 
    _USER_TASK_NOT_SET = 0,
    USER_TASK = 2,
  }
}

export enum TaskType { 
  TASK_TYPE_UNSPECIFIED = 0,
  TASK_TYPE_ONE_TIME = 1,
  TASK_TYPE_DAILY = 2,
}
export enum TaskVerificationType { 
  TASK_VERIFICATION_TYPE_UNSPECIFIED = 0,
  TASK_VERIFICATION_TYPE_BOOLEAN = 1,
  TASK_VERIFICATION_TYPE_PROGRESS = 2,
}