echofi-client/dist/generated/stats/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 stats_user_statistics_pb from '../stats/user_statistics_pb'; // proto import: "stats/user_statistics.proto"
import * as stats_point_boost_pb from '../stats/point_boost_pb'; // proto import: "stats/point_boost.proto"
import * as stats_track_statistics_pb from '../stats/track_statistics_pb'; // proto import: "stats/track_statistics.proto"


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

export namespace GetUserStatisticsRequest {
  export type AsObject = {
  }
}

export class GetUserStatisticsResponse extends jspb.Message {
  getStatistics(): stats_user_statistics_pb.UserStatistics | undefined;
  setStatistics(value?: stats_user_statistics_pb.UserStatistics): GetUserStatisticsResponse;
  hasStatistics(): boolean;
  clearStatistics(): GetUserStatisticsResponse;

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

export namespace GetUserStatisticsResponse {
  export type AsObject = {
    statistics?: stats_user_statistics_pb.UserStatistics.AsObject,
  }
}

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

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

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

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

export class ListUserStatisticsResponse extends jspb.Message {
  getStatisticsList(): Array<stats_user_statistics_pb.UserStatistics>;
  setStatisticsList(value: Array<stats_user_statistics_pb.UserStatistics>): ListUserStatisticsResponse;
  clearStatisticsList(): ListUserStatisticsResponse;
  addStatistics(value?: stats_user_statistics_pb.UserStatistics, index?: number): stats_user_statistics_pb.UserStatistics;

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

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

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

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

export namespace ListUserStatisticsResponse {
  export type AsObject = {
    statisticsList: Array<stats_user_statistics_pb.UserStatistics.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetPointBoostRequest extends jspb.Message {
  getBoostId(): number;
  setBoostId(value: number): GetPointBoostRequest;

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

export namespace GetPointBoostRequest {
  export type AsObject = {
    boostId: number,
  }
}

export class GetPointBoostResponse extends jspb.Message {
  getBoost(): stats_point_boost_pb.PointBoost | undefined;
  setBoost(value?: stats_point_boost_pb.PointBoost): GetPointBoostResponse;
  hasBoost(): boolean;
  clearBoost(): GetPointBoostResponse;

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

export namespace GetPointBoostResponse {
  export type AsObject = {
    boost?: stats_point_boost_pb.PointBoost.AsObject,
  }
}

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

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

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

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

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

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

export class ListPointBoostsResponse extends jspb.Message {
  getBoostsList(): Array<stats_point_boost_pb.PointBoost>;
  setBoostsList(value: Array<stats_point_boost_pb.PointBoost>): ListPointBoostsResponse;
  clearBoostsList(): ListPointBoostsResponse;
  addBoosts(value?: stats_point_boost_pb.PointBoost, index?: number): stats_point_boost_pb.PointBoost;

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

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

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

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

export namespace ListPointBoostsResponse {
  export type AsObject = {
    boostsList: Array<stats_point_boost_pb.PointBoost.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

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

export namespace GetUserBoostRateRequest {
  export type AsObject = {
  }
}

export class GetUserBoostRateResponse extends jspb.Message {
  getBoost(): stats_point_boost_pb.PointBoost | undefined;
  setBoost(value?: stats_point_boost_pb.PointBoost): GetUserBoostRateResponse;
  hasBoost(): boolean;
  clearBoost(): GetUserBoostRateResponse;

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

export namespace GetUserBoostRateResponse {
  export type AsObject = {
    boost?: stats_point_boost_pb.PointBoost.AsObject,
  }
}

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

  getIncludeTimeBreakdown(): boolean;
  setIncludeTimeBreakdown(value: boolean): TrackStatsRequest;

  getBreakdownPeriod(): string;
  setBreakdownPeriod(value: string): TrackStatsRequest;
  hasBreakdownPeriod(): boolean;
  clearBreakdownPeriod(): TrackStatsRequest;

  getBreakdownLimit(): number;
  setBreakdownLimit(value: number): TrackStatsRequest;
  hasBreakdownLimit(): boolean;
  clearBreakdownLimit(): TrackStatsRequest;

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

export namespace TrackStatsRequest {
  export type AsObject = {
    trackId: number,
    includeTimeBreakdown: boolean,
    breakdownPeriod?: string,
    breakdownLimit?: number,
  }

  export enum BreakdownPeriodCase { 
    _BREAKDOWN_PERIOD_NOT_SET = 0,
    BREAKDOWN_PERIOD = 3,
  }

  export enum BreakdownLimitCase { 
    _BREAKDOWN_LIMIT_NOT_SET = 0,
    BREAKDOWN_LIMIT = 4,
  }
}

export class TrackStatsResponse extends jspb.Message {
  getStatistics(): stats_track_statistics_pb.TrackStatistics | undefined;
  setStatistics(value?: stats_track_statistics_pb.TrackStatistics): TrackStatsResponse;
  hasStatistics(): boolean;
  clearStatistics(): TrackStatsResponse;

  getTimeBreakdownList(): Array<stats_track_statistics_pb.TimeBasedStats>;
  setTimeBreakdownList(value: Array<stats_track_statistics_pb.TimeBasedStats>): TrackStatsResponse;
  clearTimeBreakdownList(): TrackStatsResponse;
  addTimeBreakdown(value?: stats_track_statistics_pb.TimeBasedStats, index?: number): stats_track_statistics_pb.TimeBasedStats;

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

export namespace TrackStatsResponse {
  export type AsObject = {
    statistics?: stats_track_statistics_pb.TrackStatistics.AsObject,
    timeBreakdownList: Array<stats_track_statistics_pb.TimeBasedStats.AsObject>,
  }
}

export class ArtistStatsRequest extends jspb.Message {
  getArtistId(): number;
  setArtistId(value: number): ArtistStatsRequest;

  getIncludeTopTracks(): boolean;
  setIncludeTopTracks(value: boolean): ArtistStatsRequest;

  getTopTracksLimit(): number;
  setTopTracksLimit(value: number): ArtistStatsRequest;
  hasTopTracksLimit(): boolean;
  clearTopTracksLimit(): ArtistStatsRequest;

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

export namespace ArtistStatsRequest {
  export type AsObject = {
    artistId: number,
    includeTopTracks: boolean,
    topTracksLimit?: number,
  }

  export enum TopTracksLimitCase { 
    _TOP_TRACKS_LIMIT_NOT_SET = 0,
    TOP_TRACKS_LIMIT = 3,
  }
}

export class ArtistStatsResponse extends jspb.Message {
  getStatistics(): stats_track_statistics_pb.ArtistStatistics | undefined;
  setStatistics(value?: stats_track_statistics_pb.ArtistStatistics): ArtistStatsResponse;
  hasStatistics(): boolean;
  clearStatistics(): ArtistStatsResponse;

  getTopTracksList(): Array<stats_track_statistics_pb.TrackStatistics>;
  setTopTracksList(value: Array<stats_track_statistics_pb.TrackStatistics>): ArtistStatsResponse;
  clearTopTracksList(): ArtistStatsResponse;
  addTopTracks(value?: stats_track_statistics_pb.TrackStatistics, index?: number): stats_track_statistics_pb.TrackStatistics;

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

export namespace ArtistStatsResponse {
  export type AsObject = {
    statistics?: stats_track_statistics_pb.ArtistStatistics.AsObject,
    topTracksList: Array<stats_track_statistics_pb.TrackStatistics.AsObject>,
  }
}

export class TrendingRequest extends jspb.Message {
  getPeriodType(): string;
  setPeriodType(value: string): TrendingRequest;

  getGenreId(): number;
  setGenreId(value: number): TrendingRequest;
  hasGenreId(): boolean;
  clearGenreId(): TrendingRequest;

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

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

  getDate(): string;
  setDate(value: string): TrendingRequest;
  hasDate(): boolean;
  clearDate(): TrendingRequest;

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

export namespace TrendingRequest {
  export type AsObject = {
    periodType: string,
    genreId?: number,
    limit: number,
    offset: number,
    date?: string,
  }

  export enum GenreIdCase { 
    _GENRE_ID_NOT_SET = 0,
    GENRE_ID = 2,
  }

  export enum DateCase { 
    _DATE_NOT_SET = 0,
    DATE = 5,
  }
}

export class TrendingResponse extends jspb.Message {
  getTracksList(): Array<stats_track_statistics_pb.TrendingTrack>;
  setTracksList(value: Array<stats_track_statistics_pb.TrendingTrack>): TrendingResponse;
  clearTracksList(): TrendingResponse;
  addTracks(value?: stats_track_statistics_pb.TrendingTrack, index?: number): stats_track_statistics_pb.TrendingTrack;

  getTotalCount(): number;
  setTotalCount(value: number): TrendingResponse;

  getPeriodType(): string;
  setPeriodType(value: string): TrendingResponse;

  getPeriodDate(): string;
  setPeriodDate(value: string): TrendingResponse;

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

export namespace TrendingResponse {
  export type AsObject = {
    tracksList: Array<stats_track_statistics_pb.TrendingTrack.AsObject>,
    totalCount: number,
    periodType: string,
    periodDate: string,
  }
}