echofi-client/dist/generated/activity/service_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'

import * as activity_listening_history_pb from '../activity/listening_history_pb'; // proto import: "activity/listening_history.proto"
import * as activity_user_favorite_pb from '../activity/user_favorite_pb'; // proto import: "activity/user_favorite.proto"
import * as activity_referral_pb from '../activity/referral_pb'; // proto import: "activity/referral.proto"
import * as activity_rate_param_pb from '../activity/rate_param_pb'; // proto import: "activity/rate_param.proto"
import * as activity_listening_session_pb from '../activity/listening_session_pb'; // proto import: "activity/listening_session.proto"
import * as activity_user_points_pb from '../activity/user_points_pb'; // proto import: "activity/user_points.proto"
import * as activity_rewards_pb from '../activity/rewards_pb'; // proto import: "activity/rewards.proto"
import * as activity_user_rewards_pb from '../activity/user_rewards_pb'; // proto import: "activity/user_rewards.proto"
import * as activity_user_referral_rewards_pb from '../activity/user_referral_rewards_pb'; // proto import: "activity/user_referral_rewards.proto"
import * as activity_processing_cycles_pb from '../activity/processing_cycles_pb'; // proto import: "activity/processing_cycles.proto"
import * as music_track_pb from '../music/track_pb'; // proto import: "music/track.proto"


export class GetUserFavoriteRequest extends jspb.Message {
  getFavoriteId(): number;
  setFavoriteId(value: number): GetUserFavoriteRequest;

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

export namespace GetUserFavoriteRequest {
  export type AsObject = {
    favoriteId: number,
  }
}

export class GetUserFavoriteResponse extends jspb.Message {
  getFavorite(): activity_user_favorite_pb.UserFavorite | undefined;
  setFavorite(value?: activity_user_favorite_pb.UserFavorite): GetUserFavoriteResponse;
  hasFavorite(): boolean;
  clearFavorite(): GetUserFavoriteResponse;

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

export namespace GetUserFavoriteResponse {
  export type AsObject = {
    favorite?: activity_user_favorite_pb.UserFavorite.AsObject,
  }
}

export class ListUserFavoritesRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListUserFavoritesRequest;

  getLimit(): number;
  setLimit(value: number): ListUserFavoritesRequest;

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

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

export namespace ListUserFavoritesRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    itemType?: string,
  }

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

export class ListUserFavoritesResponse extends jspb.Message {
  getFavoritesList(): Array<activity_user_favorite_pb.UserFavorite>;
  setFavoritesList(value: Array<activity_user_favorite_pb.UserFavorite>): ListUserFavoritesResponse;
  clearFavoritesList(): ListUserFavoritesResponse;
  addFavorites(value?: activity_user_favorite_pb.UserFavorite, index?: number): activity_user_favorite_pb.UserFavorite;

  getTotal(): number;
  setTotal(value: number): ListUserFavoritesResponse;

  getOffset(): number;
  setOffset(value: number): ListUserFavoritesResponse;

  getLimit(): number;
  setLimit(value: number): ListUserFavoritesResponse;

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

export namespace ListUserFavoritesResponse {
  export type AsObject = {
    favoritesList: Array<activity_user_favorite_pb.UserFavorite.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class AddUserFavoriteRequest extends jspb.Message {
  getItemType(): string;
  setItemType(value: string): AddUserFavoriteRequest;

  getItemId(): number;
  setItemId(value: number): AddUserFavoriteRequest;

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

export namespace AddUserFavoriteRequest {
  export type AsObject = {
    itemType: string,
    itemId: number,
  }
}

export class AddUserFavoriteResponse extends jspb.Message {
  getFavorite(): activity_user_favorite_pb.UserFavorite | undefined;
  setFavorite(value?: activity_user_favorite_pb.UserFavorite): AddUserFavoriteResponse;
  hasFavorite(): boolean;
  clearFavorite(): AddUserFavoriteResponse;

  getSuccess(): boolean;
  setSuccess(value: boolean): AddUserFavoriteResponse;

  getMessage(): string;
  setMessage(value: string): AddUserFavoriteResponse;

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

export namespace AddUserFavoriteResponse {
  export type AsObject = {
    favorite?: activity_user_favorite_pb.UserFavorite.AsObject,
    success: boolean,
    message: string,
  }
}

export class RemoveUserFavoriteRequest extends jspb.Message {
  getItemType(): string;
  setItemType(value: string): RemoveUserFavoriteRequest;

  getItemId(): number;
  setItemId(value: number): RemoveUserFavoriteRequest;

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

export namespace RemoveUserFavoriteRequest {
  export type AsObject = {
    itemType: string,
    itemId: number,
  }
}

export class RemoveUserFavoriteResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): RemoveUserFavoriteResponse;

  getMessage(): string;
  setMessage(value: string): RemoveUserFavoriteResponse;

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

export namespace RemoveUserFavoriteResponse {
  export type AsObject = {
    success: boolean,
    message: string,
  }
}

export class GetRateParamRequest extends jspb.Message {
  getParamId(): number;
  setParamId(value: number): GetRateParamRequest;

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

export namespace GetRateParamRequest {
  export type AsObject = {
    paramId: number,
  }
}

export class GetRateParamResponse extends jspb.Message {
  getParam(): activity_rate_param_pb.RateParam | undefined;
  setParam(value?: activity_rate_param_pb.RateParam): GetRateParamResponse;
  hasParam(): boolean;
  clearParam(): GetRateParamResponse;

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

export namespace GetRateParamResponse {
  export type AsObject = {
    param?: activity_rate_param_pb.RateParam.AsObject,
  }
}

export class ListRateParamsRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListRateParamsRequest;

  getLimit(): number;
  setLimit(value: number): ListRateParamsRequest;

  getIsActive(): boolean;
  setIsActive(value: boolean): ListRateParamsRequest;
  hasIsActive(): boolean;
  clearIsActive(): ListRateParamsRequest;

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

export namespace ListRateParamsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    isActive?: boolean,
  }

  export enum IsActiveCase { 
    _IS_ACTIVE_NOT_SET = 0,
    IS_ACTIVE = 3,
  }
}

export class ListRateParamsResponse extends jspb.Message {
  getParamsList(): Array<activity_rate_param_pb.RateParam>;
  setParamsList(value: Array<activity_rate_param_pb.RateParam>): ListRateParamsResponse;
  clearParamsList(): ListRateParamsResponse;
  addParams(value?: activity_rate_param_pb.RateParam, index?: number): activity_rate_param_pb.RateParam;

  getTotal(): number;
  setTotal(value: number): ListRateParamsResponse;

  getOffset(): number;
  setOffset(value: number): ListRateParamsResponse;

  getLimit(): number;
  setLimit(value: number): ListRateParamsResponse;

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

export namespace ListRateParamsResponse {
  export type AsObject = {
    paramsList: Array<activity_rate_param_pb.RateParam.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

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

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

export namespace GetListeningSessionRequest {
  export type AsObject = {
    id: string,
  }
}

export class GetListeningSessionResponse extends jspb.Message {
  getSession(): activity_listening_session_pb.ListeningSession | undefined;
  setSession(value?: activity_listening_session_pb.ListeningSession): GetListeningSessionResponse;
  hasSession(): boolean;
  clearSession(): GetListeningSessionResponse;

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

export namespace GetListeningSessionResponse {
  export type AsObject = {
    session?: activity_listening_session_pb.ListeningSession.AsObject,
  }
}

export class ListListeningSessionsRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListListeningSessionsRequest;

  getLimit(): number;
  setLimit(value: number): ListListeningSessionsRequest;

  getStatus(): string;
  setStatus(value: string): ListListeningSessionsRequest;
  hasStatus(): boolean;
  clearStatus(): ListListeningSessionsRequest;

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

export namespace ListListeningSessionsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    status?: string,
  }

  export enum StatusCase { 
    _STATUS_NOT_SET = 0,
    STATUS = 3,
  }
}

export class ListeningSessionWithTrack extends jspb.Message {
  getSession(): activity_listening_session_pb.ListeningSession | undefined;
  setSession(value?: activity_listening_session_pb.ListeningSession): ListeningSessionWithTrack;
  hasSession(): boolean;
  clearSession(): ListeningSessionWithTrack;

  getTrack(): ListeningSessionWithTrack.TrackMetadata | undefined;
  setTrack(value?: ListeningSessionWithTrack.TrackMetadata): ListeningSessionWithTrack;
  hasTrack(): boolean;
  clearTrack(): ListeningSessionWithTrack;

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

export namespace ListeningSessionWithTrack {
  export type AsObject = {
    session?: activity_listening_session_pb.ListeningSession.AsObject,
    track?: ListeningSessionWithTrack.TrackMetadata.AsObject,
  }

  export class TrackMetadata extends jspb.Message {
    getTrackId(): number;
    setTrackId(value: number): TrackMetadata;

    getTitle(): string;
    setTitle(value: string): TrackMetadata;

    getImageUrl(): string;
    setImageUrl(value: string): TrackMetadata;

    getSource(): string;
    setSource(value: string): TrackMetadata;

    getUrl(): string;
    setUrl(value: string): TrackMetadata;

    getArtistId(): number;
    setArtistId(value: number): TrackMetadata;

    getArtistName(): string;
    setArtistName(value: string): TrackMetadata;

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

  export namespace TrackMetadata {
    export type AsObject = {
      trackId: number,
      title: string,
      imageUrl: string,
      source: string,
      url: string,
      artistId: number,
      artistName: string,
    }
  }

}

export class ListListeningSessionsResponse extends jspb.Message {
  getSessionsList(): Array<ListeningSessionWithTrack>;
  setSessionsList(value: Array<ListeningSessionWithTrack>): ListListeningSessionsResponse;
  clearSessionsList(): ListListeningSessionsResponse;
  addSessions(value?: ListeningSessionWithTrack, index?: number): ListeningSessionWithTrack;

  getTotal(): number;
  setTotal(value: number): ListListeningSessionsResponse;

  getOffset(): number;
  setOffset(value: number): ListListeningSessionsResponse;

  getLimit(): number;
  setLimit(value: number): ListListeningSessionsResponse;

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

export namespace ListListeningSessionsResponse {
  export type AsObject = {
    sessionsList: Array<ListeningSessionWithTrack.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetListeningHistoryRequest extends jspb.Message {
  getHistoryId(): number;
  setHistoryId(value: number): GetListeningHistoryRequest;

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

export namespace GetListeningHistoryRequest {
  export type AsObject = {
    historyId: number,
  }
}

export class GetListeningHistoryResponse extends jspb.Message {
  getHistory(): activity_listening_history_pb.ListeningHistory | undefined;
  setHistory(value?: activity_listening_history_pb.ListeningHistory): GetListeningHistoryResponse;
  hasHistory(): boolean;
  clearHistory(): GetListeningHistoryResponse;

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

export namespace GetListeningHistoryResponse {
  export type AsObject = {
    history?: activity_listening_history_pb.ListeningHistory.AsObject,
  }
}

export class ListListeningHistoryRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListListeningHistoryRequest;

  getLimit(): number;
  setLimit(value: number): ListListeningHistoryRequest;

  getTrackId(): number;
  setTrackId(value: number): ListListeningHistoryRequest;
  hasTrackId(): boolean;
  clearTrackId(): ListListeningHistoryRequest;

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

export namespace ListListeningHistoryRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    trackId?: number,
  }

  export enum TrackIdCase { 
    _TRACK_ID_NOT_SET = 0,
    TRACK_ID = 3,
  }
}

export class ListeningHistoryWithTrack extends jspb.Message {
  getHistory(): activity_listening_history_pb.ListeningHistory | undefined;
  setHistory(value?: activity_listening_history_pb.ListeningHistory): ListeningHistoryWithTrack;
  hasHistory(): boolean;
  clearHistory(): ListeningHistoryWithTrack;

  getTrack(): ListeningHistoryWithTrack.TrackMetadata | undefined;
  setTrack(value?: ListeningHistoryWithTrack.TrackMetadata): ListeningHistoryWithTrack;
  hasTrack(): boolean;
  clearTrack(): ListeningHistoryWithTrack;

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

export namespace ListeningHistoryWithTrack {
  export type AsObject = {
    history?: activity_listening_history_pb.ListeningHistory.AsObject,
    track?: ListeningHistoryWithTrack.TrackMetadata.AsObject,
  }

  export class TrackMetadata extends jspb.Message {
    getTrackId(): number;
    setTrackId(value: number): TrackMetadata;

    getTitle(): string;
    setTitle(value: string): TrackMetadata;

    getImageUrl(): string;
    setImageUrl(value: string): TrackMetadata;

    getSource(): string;
    setSource(value: string): TrackMetadata;

    getUrl(): string;
    setUrl(value: string): TrackMetadata;

    getArtistId(): number;
    setArtistId(value: number): TrackMetadata;

    getArtistName(): string;
    setArtistName(value: string): TrackMetadata;

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

  export namespace TrackMetadata {
    export type AsObject = {
      trackId: number,
      title: string,
      imageUrl: string,
      source: string,
      url: string,
      artistId: number,
      artistName: string,
    }
  }

}

export class ListListeningHistoryResponse extends jspb.Message {
  getHistoriesList(): Array<ListeningHistoryWithTrack>;
  setHistoriesList(value: Array<ListeningHistoryWithTrack>): ListListeningHistoryResponse;
  clearHistoriesList(): ListListeningHistoryResponse;
  addHistories(value?: ListeningHistoryWithTrack, index?: number): ListeningHistoryWithTrack;

  getTotal(): number;
  setTotal(value: number): ListListeningHistoryResponse;

  getOffset(): number;
  setOffset(value: number): ListListeningHistoryResponse;

  getLimit(): number;
  setLimit(value: number): ListListeningHistoryResponse;

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

export namespace ListListeningHistoryResponse {
  export type AsObject = {
    historiesList: Array<ListeningHistoryWithTrack.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetUserPointsRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetUserPointsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetUserPointsRequest): GetUserPointsRequest.AsObject;
  static serializeBinaryToWriter(message: GetUserPointsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetUserPointsRequest;
  static deserializeBinaryFromReader(message: GetUserPointsRequest, reader: jspb.BinaryReader): GetUserPointsRequest;
}

export namespace GetUserPointsRequest {
  export type AsObject = {
  }
}

export class GetUserPointsResponse extends jspb.Message {
  getPoints(): activity_user_points_pb.UserPoints | undefined;
  setPoints(value?: activity_user_points_pb.UserPoints): GetUserPointsResponse;
  hasPoints(): boolean;
  clearPoints(): GetUserPointsResponse;

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

export namespace GetUserPointsResponse {
  export type AsObject = {
    points?: activity_user_points_pb.UserPoints.AsObject,
  }
}

export class ListUserPointsRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListUserPointsRequest;

  getLimit(): number;
  setLimit(value: number): ListUserPointsRequest;

  getStatus(): string;
  setStatus(value: string): ListUserPointsRequest;
  hasStatus(): boolean;
  clearStatus(): ListUserPointsRequest;

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

export namespace ListUserPointsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    status?: string,
  }

  export enum StatusCase { 
    _STATUS_NOT_SET = 0,
    STATUS = 3,
  }
}

export class ListUserPointsResponse extends jspb.Message {
  getPointsList(): Array<activity_user_points_pb.UserPoints>;
  setPointsList(value: Array<activity_user_points_pb.UserPoints>): ListUserPointsResponse;
  clearPointsList(): ListUserPointsResponse;
  addPoints(value?: activity_user_points_pb.UserPoints, index?: number): activity_user_points_pb.UserPoints;

  getTotal(): number;
  setTotal(value: number): ListUserPointsResponse;

  getOffset(): number;
  setOffset(value: number): ListUserPointsResponse;

  getLimit(): number;
  setLimit(value: number): ListUserPointsResponse;

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

export namespace ListUserPointsResponse {
  export type AsObject = {
    pointsList: Array<activity_user_points_pb.UserPoints.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetUnprocessedListeningRecordsRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): GetUnprocessedListeningRecordsRequest;

  getLimit(): number;
  setLimit(value: number): GetUnprocessedListeningRecordsRequest;

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

export namespace GetUnprocessedListeningRecordsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
  }
}

export class GetUnprocessedListeningRecordsResponse extends jspb.Message {
  getSessionsList(): Array<activity_listening_session_pb.ListeningSession>;
  setSessionsList(value: Array<activity_listening_session_pb.ListeningSession>): GetUnprocessedListeningRecordsResponse;
  clearSessionsList(): GetUnprocessedListeningRecordsResponse;
  addSessions(value?: activity_listening_session_pb.ListeningSession, index?: number): activity_listening_session_pb.ListeningSession;

  getTotal(): number;
  setTotal(value: number): GetUnprocessedListeningRecordsResponse;

  getOffset(): number;
  setOffset(value: number): GetUnprocessedListeningRecordsResponse;

  getLimit(): number;
  setLimit(value: number): GetUnprocessedListeningRecordsResponse;

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

export namespace GetUnprocessedListeningRecordsResponse {
  export type AsObject = {
    sessionsList: Array<activity_listening_session_pb.ListeningSession.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetUnprocessedListeningDurationRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetUnprocessedListeningDurationRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetUnprocessedListeningDurationRequest): GetUnprocessedListeningDurationRequest.AsObject;
  static serializeBinaryToWriter(message: GetUnprocessedListeningDurationRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetUnprocessedListeningDurationRequest;
  static deserializeBinaryFromReader(message: GetUnprocessedListeningDurationRequest, reader: jspb.BinaryReader): GetUnprocessedListeningDurationRequest;
}

export namespace GetUnprocessedListeningDurationRequest {
  export type AsObject = {
  }
}

export class GetUnprocessedListeningDurationResponse extends jspb.Message {
  getTotalDurationSeconds(): number;
  setTotalDurationSeconds(value: number): GetUnprocessedListeningDurationResponse;

  getSessionCount(): number;
  setSessionCount(value: number): GetUnprocessedListeningDurationResponse;

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

export namespace GetUnprocessedListeningDurationResponse {
  export type AsObject = {
    totalDurationSeconds: number,
    sessionCount: number,
  }
}

export class SetReferrerRequest extends jspb.Message {
  getReferrerId(): string;
  setReferrerId(value: string): SetReferrerRequest;

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

export namespace SetReferrerRequest {
  export type AsObject = {
    referrerId: string,
  }
}

export class SetReferrerResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): SetReferrerResponse;

  getMessage(): string;
  setMessage(value: string): SetReferrerResponse;

  getReferral(): activity_referral_pb.Referral | undefined;
  setReferral(value?: activity_referral_pb.Referral): SetReferrerResponse;
  hasReferral(): boolean;
  clearReferral(): SetReferrerResponse;

  getReferrerStats(): activity_referral_pb.UserReferrals | undefined;
  setReferrerStats(value?: activity_referral_pb.UserReferrals): SetReferrerResponse;
  hasReferrerStats(): boolean;
  clearReferrerStats(): SetReferrerResponse;

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

export namespace SetReferrerResponse {
  export type AsObject = {
    success: boolean,
    message: string,
    referral?: activity_referral_pb.Referral.AsObject,
    referrerStats?: activity_referral_pb.UserReferrals.AsObject,
  }
}

export class GetUserReferralRewardsRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetUserReferralRewardsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetUserReferralRewardsRequest): GetUserReferralRewardsRequest.AsObject;
  static serializeBinaryToWriter(message: GetUserReferralRewardsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetUserReferralRewardsRequest;
  static deserializeBinaryFromReader(message: GetUserReferralRewardsRequest, reader: jspb.BinaryReader): GetUserReferralRewardsRequest;
}

export namespace GetUserReferralRewardsRequest {
  export type AsObject = {
  }
}

export class GetUserReferralRewardsResponse extends jspb.Message {
  getReferralRewards(): activity_user_referral_rewards_pb.UserReferralRewards | undefined;
  setReferralRewards(value?: activity_user_referral_rewards_pb.UserReferralRewards): GetUserReferralRewardsResponse;
  hasReferralRewards(): boolean;
  clearReferralRewards(): GetUserReferralRewardsResponse;

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

export namespace GetUserReferralRewardsResponse {
  export type AsObject = {
    referralRewards?: activity_user_referral_rewards_pb.UserReferralRewards.AsObject,
  }
}

export class ListUserRefereesRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListUserRefereesRequest;

  getLimit(): number;
  setLimit(value: number): ListUserRefereesRequest;

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

export namespace ListUserRefereesRequest {
  export type AsObject = {
    offset: number,
    limit: number,
  }
}

export class ListUserRefereesResponse extends jspb.Message {
  getRefereesList(): Array<activity_referral_pb.Referral>;
  setRefereesList(value: Array<activity_referral_pb.Referral>): ListUserRefereesResponse;
  clearRefereesList(): ListUserRefereesResponse;
  addReferees(value?: activity_referral_pb.Referral, index?: number): activity_referral_pb.Referral;

  getTotal(): number;
  setTotal(value: number): ListUserRefereesResponse;

  getOffset(): number;
  setOffset(value: number): ListUserRefereesResponse;

  getLimit(): number;
  setLimit(value: number): ListUserRefereesResponse;

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

export namespace ListUserRefereesResponse {
  export type AsObject = {
    refereesList: Array<activity_referral_pb.Referral.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetUserRewardsRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): GetUserRewardsRequest;

  getLimit(): number;
  setLimit(value: number): GetUserRewardsRequest;

  getClaimed(): boolean;
  setClaimed(value: boolean): GetUserRewardsRequest;
  hasClaimed(): boolean;
  clearClaimed(): GetUserRewardsRequest;

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

export namespace GetUserRewardsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    claimed?: boolean,
  }

  export enum ClaimedCase { 
    _CLAIMED_NOT_SET = 0,
    CLAIMED = 3,
  }
}

export class GetUserRewardsResponse extends jspb.Message {
  getRewardsList(): Array<activity_user_rewards_pb.UserRewards>;
  setRewardsList(value: Array<activity_user_rewards_pb.UserRewards>): GetUserRewardsResponse;
  clearRewardsList(): GetUserRewardsResponse;
  addRewards(value?: activity_user_rewards_pb.UserRewards, index?: number): activity_user_rewards_pb.UserRewards;

  getTotal(): number;
  setTotal(value: number): GetUserRewardsResponse;

  getOffset(): number;
  setOffset(value: number): GetUserRewardsResponse;

  getLimit(): number;
  setLimit(value: number): GetUserRewardsResponse;

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

export namespace GetUserRewardsResponse {
  export type AsObject = {
    rewardsList: Array<activity_user_rewards_pb.UserRewards.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class ListRewardsRequest extends jspb.Message {
  getOffset(): number;
  setOffset(value: number): ListRewardsRequest;

  getLimit(): number;
  setLimit(value: number): ListRewardsRequest;

  getIsActive(): boolean;
  setIsActive(value: boolean): ListRewardsRequest;
  hasIsActive(): boolean;
  clearIsActive(): ListRewardsRequest;

  getRewardType(): string;
  setRewardType(value: string): ListRewardsRequest;
  hasRewardType(): boolean;
  clearRewardType(): ListRewardsRequest;

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

export namespace ListRewardsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    isActive?: boolean,
    rewardType?: string,
  }

  export enum IsActiveCase { 
    _IS_ACTIVE_NOT_SET = 0,
    IS_ACTIVE = 3,
  }

  export enum RewardTypeCase { 
    _REWARD_TYPE_NOT_SET = 0,
    REWARD_TYPE = 4,
  }
}

export class ListRewardsResponse extends jspb.Message {
  getRewardsList(): Array<activity_rewards_pb.Rewards>;
  setRewardsList(value: Array<activity_rewards_pb.Rewards>): ListRewardsResponse;
  clearRewardsList(): ListRewardsResponse;
  addRewards(value?: activity_rewards_pb.Rewards, index?: number): activity_rewards_pb.Rewards;

  getTotal(): number;
  setTotal(value: number): ListRewardsResponse;

  getOffset(): number;
  setOffset(value: number): ListRewardsResponse;

  getLimit(): number;
  setLimit(value: number): ListRewardsResponse;

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

export namespace ListRewardsResponse {
  export type AsObject = {
    rewardsList: Array<activity_rewards_pb.Rewards.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}