echofi-client/dist/generated/music/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 music_artist_pb from '../music/artist_pb'; // proto import: "music/artist.proto"
import * as music_album_pb from '../music/album_pb'; // proto import: "music/album.proto"
import * as music_track_pb from '../music/track_pb'; // proto import: "music/track.proto"
import * as music_genre_pb from '../music/genre_pb'; // proto import: "music/genre.proto"
import * as music_playlist_pb from '../music/playlist_pb'; // proto import: "music/playlist.proto"


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

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

export namespace GetArtistRequest {
  export type AsObject = {
    artistId: number,
  }
}

export class GetArtistResponse extends jspb.Message {
  getArtist(): music_artist_pb.Artist | undefined;
  setArtist(value?: music_artist_pb.Artist): GetArtistResponse;
  hasArtist(): boolean;
  clearArtist(): GetArtistResponse;

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

export namespace GetArtistResponse {
  export type AsObject = {
    artist?: music_artist_pb.Artist.AsObject,
  }
}

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

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

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

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

export class ListArtistsResponse extends jspb.Message {
  getArtistsList(): Array<music_artist_pb.Artist>;
  setArtistsList(value: Array<music_artist_pb.Artist>): ListArtistsResponse;
  clearArtistsList(): ListArtistsResponse;
  addArtists(value?: music_artist_pb.Artist, index?: number): music_artist_pb.Artist;

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

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

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

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

export namespace ListArtistsResponse {
  export type AsObject = {
    artistsList: Array<music_artist_pb.Artist.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetAlbumRequest extends jspb.Message {
  getAlbumId(): number;
  setAlbumId(value: number): GetAlbumRequest;

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

export namespace GetAlbumRequest {
  export type AsObject = {
    albumId: number,
  }
}

export class GetAlbumResponse extends jspb.Message {
  getAlbum(): music_album_pb.Album | undefined;
  setAlbum(value?: music_album_pb.Album): GetAlbumResponse;
  hasAlbum(): boolean;
  clearAlbum(): GetAlbumResponse;

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

export namespace GetAlbumResponse {
  export type AsObject = {
    album?: music_album_pb.Album.AsObject,
  }
}

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

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

  getArtistId(): number;
  setArtistId(value: number): ListAlbumsRequest;
  hasArtistId(): boolean;
  clearArtistId(): ListAlbumsRequest;

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

export namespace ListAlbumsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    artistId?: number,
  }

  export enum ArtistIdCase { 
    _ARTIST_ID_NOT_SET = 0,
    ARTIST_ID = 3,
  }
}

export class ListAlbumsResponse extends jspb.Message {
  getAlbumsList(): Array<music_album_pb.Album>;
  setAlbumsList(value: Array<music_album_pb.Album>): ListAlbumsResponse;
  clearAlbumsList(): ListAlbumsResponse;
  addAlbums(value?: music_album_pb.Album, index?: number): music_album_pb.Album;

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

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

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

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

export namespace ListAlbumsResponse {
  export type AsObject = {
    albumsList: Array<music_album_pb.Album.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

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

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

export namespace GetTrackRequest {
  export type AsObject = {
    trackId: number,
  }
}

export class GetTrackResponse extends jspb.Message {
  getTrack(): music_track_pb.Track | undefined;
  setTrack(value?: music_track_pb.Track): GetTrackResponse;
  hasTrack(): boolean;
  clearTrack(): GetTrackResponse;

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

export namespace GetTrackResponse {
  export type AsObject = {
    track?: music_track_pb.Track.AsObject,
  }
}

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

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

  getArtistId(): number;
  setArtistId(value: number): ListTracksRequest;
  hasArtistId(): boolean;
  clearArtistId(): ListTracksRequest;

  getAlbumId(): number;
  setAlbumId(value: number): ListTracksRequest;
  hasAlbumId(): boolean;
  clearAlbumId(): ListTracksRequest;

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

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

export namespace ListTracksRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    artistId?: number,
    albumId?: number,
    genreId?: number,
  }

  export enum ArtistIdCase { 
    _ARTIST_ID_NOT_SET = 0,
    ARTIST_ID = 3,
  }

  export enum AlbumIdCase { 
    _ALBUM_ID_NOT_SET = 0,
    ALBUM_ID = 4,
  }

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

export class ListTracksResponse extends jspb.Message {
  getTracksList(): Array<music_track_pb.Track>;
  setTracksList(value: Array<music_track_pb.Track>): ListTracksResponse;
  clearTracksList(): ListTracksResponse;
  addTracks(value?: music_track_pb.Track, index?: number): music_track_pb.Track;

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

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

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

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

export namespace ListTracksResponse {
  export type AsObject = {
    tracksList: Array<music_track_pb.Track.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetGenreRequest extends jspb.Message {
  getGenreId(): number;
  setGenreId(value: number): GetGenreRequest;

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

export namespace GetGenreRequest {
  export type AsObject = {
    genreId: number,
  }
}

export class GetGenreResponse extends jspb.Message {
  getGenre(): music_genre_pb.Genre | undefined;
  setGenre(value?: music_genre_pb.Genre): GetGenreResponse;
  hasGenre(): boolean;
  clearGenre(): GetGenreResponse;

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

export namespace GetGenreResponse {
  export type AsObject = {
    genre?: music_genre_pb.Genre.AsObject,
  }
}

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

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

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

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

export class ListGenresResponse extends jspb.Message {
  getGenresList(): Array<music_genre_pb.Genre>;
  setGenresList(value: Array<music_genre_pb.Genre>): ListGenresResponse;
  clearGenresList(): ListGenresResponse;
  addGenres(value?: music_genre_pb.Genre, index?: number): music_genre_pb.Genre;

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

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

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

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

export namespace ListGenresResponse {
  export type AsObject = {
    genresList: Array<music_genre_pb.Genre.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetPlaylistRequest extends jspb.Message {
  getPlaylistId(): string;
  setPlaylistId(value: string): GetPlaylistRequest;

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

export namespace GetPlaylistRequest {
  export type AsObject = {
    playlistId: string,
  }
}

export class GetPlaylistResponse extends jspb.Message {
  getPlaylist(): music_playlist_pb.Playlist | undefined;
  setPlaylist(value?: music_playlist_pb.Playlist): GetPlaylistResponse;
  hasPlaylist(): boolean;
  clearPlaylist(): GetPlaylistResponse;

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

export namespace GetPlaylistResponse {
  export type AsObject = {
    playlist?: music_playlist_pb.Playlist.AsObject,
  }
}

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

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

  getCreatedBy(): string;
  setCreatedBy(value: string): ListPlaylistsRequest;
  hasCreatedBy(): boolean;
  clearCreatedBy(): ListPlaylistsRequest;

  getIsPublic(): boolean;
  setIsPublic(value: boolean): ListPlaylistsRequest;
  hasIsPublic(): boolean;
  clearIsPublic(): ListPlaylistsRequest;

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

export namespace ListPlaylistsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    createdBy?: string,
    isPublic?: boolean,
  }

  export enum CreatedByCase { 
    _CREATED_BY_NOT_SET = 0,
    CREATED_BY = 3,
  }

  export enum IsPublicCase { 
    _IS_PUBLIC_NOT_SET = 0,
    IS_PUBLIC = 4,
  }
}

export class ListPlaylistsResponse extends jspb.Message {
  getPlaylistsList(): Array<music_playlist_pb.Playlist>;
  setPlaylistsList(value: Array<music_playlist_pb.Playlist>): ListPlaylistsResponse;
  clearPlaylistsList(): ListPlaylistsResponse;
  addPlaylists(value?: music_playlist_pb.Playlist, index?: number): music_playlist_pb.Playlist;

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

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

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

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

export namespace ListPlaylistsResponse {
  export type AsObject = {
    playlistsList: Array<music_playlist_pb.Playlist.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

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

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

  getIsPublic(): boolean;
  setIsPublic(value: boolean): GetUserPlaylistsRequest;
  hasIsPublic(): boolean;
  clearIsPublic(): GetUserPlaylistsRequest;

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

export namespace GetUserPlaylistsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    isPublic?: boolean,
  }

  export enum IsPublicCase { 
    _IS_PUBLIC_NOT_SET = 0,
    IS_PUBLIC = 3,
  }
}

export class GetUserPlaylistsResponse extends jspb.Message {
  getPlaylistsList(): Array<music_playlist_pb.Playlist>;
  setPlaylistsList(value: Array<music_playlist_pb.Playlist>): GetUserPlaylistsResponse;
  clearPlaylistsList(): GetUserPlaylistsResponse;
  addPlaylists(value?: music_playlist_pb.Playlist, index?: number): music_playlist_pb.Playlist;

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

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

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

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

export namespace GetUserPlaylistsResponse {
  export type AsObject = {
    playlistsList: Array<music_playlist_pb.Playlist.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

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

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

  getIsFeatured(): boolean;
  setIsFeatured(value: boolean): GetPublicPlaylistsRequest;
  hasIsFeatured(): boolean;
  clearIsFeatured(): GetPublicPlaylistsRequest;

  getIsOfficial(): boolean;
  setIsOfficial(value: boolean): GetPublicPlaylistsRequest;
  hasIsOfficial(): boolean;
  clearIsOfficial(): GetPublicPlaylistsRequest;

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

export namespace GetPublicPlaylistsRequest {
  export type AsObject = {
    offset: number,
    limit: number,
    isFeatured?: boolean,
    isOfficial?: boolean,
  }

  export enum IsFeaturedCase { 
    _IS_FEATURED_NOT_SET = 0,
    IS_FEATURED = 3,
  }

  export enum IsOfficialCase { 
    _IS_OFFICIAL_NOT_SET = 0,
    IS_OFFICIAL = 4,
  }
}

export class GetPublicPlaylistsResponse extends jspb.Message {
  getPlaylistsList(): Array<music_playlist_pb.Playlist>;
  setPlaylistsList(value: Array<music_playlist_pb.Playlist>): GetPublicPlaylistsResponse;
  clearPlaylistsList(): GetPublicPlaylistsResponse;
  addPlaylists(value?: music_playlist_pb.Playlist, index?: number): music_playlist_pb.Playlist;

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

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

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

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

export namespace GetPublicPlaylistsResponse {
  export type AsObject = {
    playlistsList: Array<music_playlist_pb.Playlist.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class ListPlaylistTracksRequest extends jspb.Message {
  getPlaylistId(): string;
  setPlaylistId(value: string): ListPlaylistTracksRequest;

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

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

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

export namespace ListPlaylistTracksRequest {
  export type AsObject = {
    playlistId: string,
    offset: number,
    limit: number,
  }
}

export class ListPlaylistTracksResponse extends jspb.Message {
  getTracksList(): Array<music_playlist_pb.PlaylistTrackWithDetails>;
  setTracksList(value: Array<music_playlist_pb.PlaylistTrackWithDetails>): ListPlaylistTracksResponse;
  clearTracksList(): ListPlaylistTracksResponse;
  addTracks(value?: music_playlist_pb.PlaylistTrackWithDetails, index?: number): music_playlist_pb.PlaylistTrackWithDetails;

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

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

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

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

export namespace ListPlaylistTracksResponse {
  export type AsObject = {
    tracksList: Array<music_playlist_pb.PlaylistTrackWithDetails.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class GetPlaylistTracksRequest extends jspb.Message {
  getPlaylistId(): string;
  setPlaylistId(value: string): GetPlaylistTracksRequest;

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

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

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

export namespace GetPlaylistTracksRequest {
  export type AsObject = {
    playlistId: string,
    offset: number,
    limit: number,
  }
}

export class GetPlaylistTracksResponse extends jspb.Message {
  getTracksList(): Array<music_playlist_pb.PlaylistTrackWithDetails>;
  setTracksList(value: Array<music_playlist_pb.PlaylistTrackWithDetails>): GetPlaylistTracksResponse;
  clearTracksList(): GetPlaylistTracksResponse;
  addTracks(value?: music_playlist_pb.PlaylistTrackWithDetails, index?: number): music_playlist_pb.PlaylistTrackWithDetails;

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

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

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

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

export namespace GetPlaylistTracksResponse {
  export type AsObject = {
    tracksList: Array<music_playlist_pb.PlaylistTrackWithDetails.AsObject>,
    total: number,
    offset: number,
    limit: number,
  }
}

export class CreatePlaylistRequest extends jspb.Message {
  getTitle(): string;
  setTitle(value: string): CreatePlaylistRequest;

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

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

  getIsPublic(): boolean;
  setIsPublic(value: boolean): CreatePlaylistRequest;

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

export namespace CreatePlaylistRequest {
  export type AsObject = {
    title: string,
    description: string,
    imageUrl: string,
    isPublic: boolean,
  }
}

export class CreatePlaylistResponse extends jspb.Message {
  getPlaylist(): music_playlist_pb.Playlist | undefined;
  setPlaylist(value?: music_playlist_pb.Playlist): CreatePlaylistResponse;
  hasPlaylist(): boolean;
  clearPlaylist(): CreatePlaylistResponse;

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

export namespace CreatePlaylistResponse {
  export type AsObject = {
    playlist?: music_playlist_pb.Playlist.AsObject,
  }
}

export class UpdatePlaylistRequest extends jspb.Message {
  getPlaylistId(): string;
  setPlaylistId(value: string): UpdatePlaylistRequest;

  getTitle(): string;
  setTitle(value: string): UpdatePlaylistRequest;
  hasTitle(): boolean;
  clearTitle(): UpdatePlaylistRequest;

  getDescription(): string;
  setDescription(value: string): UpdatePlaylistRequest;
  hasDescription(): boolean;
  clearDescription(): UpdatePlaylistRequest;

  getImageUrl(): string;
  setImageUrl(value: string): UpdatePlaylistRequest;
  hasImageUrl(): boolean;
  clearImageUrl(): UpdatePlaylistRequest;

  getIsPublic(): boolean;
  setIsPublic(value: boolean): UpdatePlaylistRequest;
  hasIsPublic(): boolean;
  clearIsPublic(): UpdatePlaylistRequest;

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

export namespace UpdatePlaylistRequest {
  export type AsObject = {
    playlistId: string,
    title?: string,
    description?: string,
    imageUrl?: string,
    isPublic?: boolean,
  }

  export enum TitleCase { 
    _TITLE_NOT_SET = 0,
    TITLE = 2,
  }

  export enum DescriptionCase { 
    _DESCRIPTION_NOT_SET = 0,
    DESCRIPTION = 3,
  }

  export enum ImageUrlCase { 
    _IMAGE_URL_NOT_SET = 0,
    IMAGE_URL = 4,
  }

  export enum IsPublicCase { 
    _IS_PUBLIC_NOT_SET = 0,
    IS_PUBLIC = 5,
  }
}

export class UpdatePlaylistResponse extends jspb.Message {
  getPlaylist(): music_playlist_pb.Playlist | undefined;
  setPlaylist(value?: music_playlist_pb.Playlist): UpdatePlaylistResponse;
  hasPlaylist(): boolean;
  clearPlaylist(): UpdatePlaylistResponse;

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

export namespace UpdatePlaylistResponse {
  export type AsObject = {
    playlist?: music_playlist_pb.Playlist.AsObject,
  }
}

export class DeletePlaylistRequest extends jspb.Message {
  getPlaylistId(): string;
  setPlaylistId(value: string): DeletePlaylistRequest;

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

export namespace DeletePlaylistRequest {
  export type AsObject = {
    playlistId: string,
  }
}

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

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

export namespace DeletePlaylistResponse {
  export type AsObject = {
    success: boolean,
  }
}

export class UpdatePlaylistTracksRequest extends jspb.Message {
  getPlaylistId(): string;
  setPlaylistId(value: string): UpdatePlaylistTracksRequest;

  getTrackIdsList(): Array<number>;
  setTrackIdsList(value: Array<number>): UpdatePlaylistTracksRequest;
  clearTrackIdsList(): UpdatePlaylistTracksRequest;
  addTrackIds(value: number, index?: number): UpdatePlaylistTracksRequest;

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

export namespace UpdatePlaylistTracksRequest {
  export type AsObject = {
    playlistId: string,
    trackIdsList: Array<number>,
  }
}

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

  getTracksCount(): number;
  setTracksCount(value: number): UpdatePlaylistTracksResponse;

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

export namespace UpdatePlaylistTracksResponse {
  export type AsObject = {
    success: boolean,
    tracksCount: number,
  }
}