import * as jspb from 'google-protobuf'



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

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

  getFullname(): string;
  setFullname(value: string): Person;

  getAliasesList(): Array<string>;
  setAliasesList(value: Array<string>): Person;
  clearAliasesList(): Person;
  addAliases(value: string, index?: number): Person;

  getPicture(): string;
  setPicture(value: string): Person;

  getBiography(): string;
  setBiography(value: string): Person;

  getCareersatus(): string;
  setCareersatus(value: string): Person;

  getGender(): string;
  setGender(value: string): Person;

  getBirthplace(): string;
  setBirthplace(value: string): Person;

  getBirthdate(): string;
  setBirthdate(value: string): Person;

  getDirectingList(): Array<string>;
  setDirectingList(value: Array<string>): Person;
  clearDirectingList(): Person;
  addDirecting(value: string, index?: number): Person;

  getWritingList(): Array<string>;
  setWritingList(value: Array<string>): Person;
  clearWritingList(): Person;
  addWriting(value: string, index?: number): Person;

  getActingList(): Array<string>;
  setActingList(value: Array<string>): Person;
  clearActingList(): Person;
  addActing(value: string, index?: number): Person;

  getCastingList(): Array<string>;
  setCastingList(value: Array<string>): Person;
  clearCastingList(): Person;
  addCasting(value: string, index?: number): Person;

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

export namespace Person {
  export type AsObject = {
    id: string,
    url: string,
    fullname: string,
    aliasesList: Array<string>,
    picture: string,
    biography: string,
    careersatus: string,
    gender: string,
    birthplace: string,
    birthdate: string,
    directingList: Array<string>,
    writingList: Array<string>,
    actingList: Array<string>,
    castingList: Array<string>,
  }
}

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

  getTitleid(): string;
  setTitleid(value: string): Poster;

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

  getContenturl(): string;
  setContenturl(value: string): Poster;

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

export namespace Poster {
  export type AsObject = {
    id: string,
    titleid: string,
    url: string,
    contenturl: string,
  }
}

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

  getTitleid(): string;
  setTitleid(value: string): Preview;

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

  getContenturl(): string;
  setContenturl(value: string): Preview;

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

export namespace Preview {
  export type AsObject = {
    id: string,
    titleid: string,
    url: string,
    contenturl: string,
  }
}

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

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

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

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

export namespace Publisher {
  export type AsObject = {
    id: string,
    url: string,
    name: string,
  }
}

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

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

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

  getPublisherid(): Publisher | undefined;
  setPublisherid(value?: Publisher): Video;
  hasPublisherid(): boolean;
  clearPublisherid(): Video;

  getCount(): number;
  setCount(value: number): Video;

  getRating(): number;
  setRating(value: number): Video;

  getLikes(): number;
  setLikes(value: number): Video;

  getDate(): string;
  setDate(value: string): Video;

  getGenresList(): Array<string>;
  setGenresList(value: Array<string>): Video;
  clearGenresList(): Video;
  addGenres(value: string, index?: number): Video;

  getTagsList(): Array<string>;
  setTagsList(value: Array<string>): Video;
  clearTagsList(): Video;
  addTags(value: string, index?: number): Video;

  getCastingList(): Array<Person>;
  setCastingList(value: Array<Person>): Video;
  clearCastingList(): Video;
  addCasting(value?: Person, index?: number): Person;

  getPoster(): Poster | undefined;
  setPoster(value?: Poster): Video;
  hasPoster(): boolean;
  clearPoster(): Video;

  getPreview(): Preview | undefined;
  setPreview(value?: Preview): Video;
  hasPreview(): boolean;
  clearPreview(): Video;

  getDuration(): number;
  setDuration(value: number): Video;

  getUuid(): string;
  setUuid(value: string): Video;

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

export namespace Video {
  export type AsObject = {
    id: string,
    url: string,
    description: string,
    publisherid?: Publisher.AsObject,
    count: number,
    rating: number,
    likes: number,
    date: string,
    genresList: Array<string>,
    tagsList: Array<string>,
    castingList: Array<Person.AsObject>,
    poster?: Poster.AsObject,
    preview?: Preview.AsObject,
    duration: number,
    uuid: string,
  }
}

export class Videos extends jspb.Message {
  getVideosList(): Array<Video>;
  setVideosList(value: Array<Video>): Videos;
  clearVideosList(): Videos;
  addVideos(value?: Video, index?: number): Video;

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

export namespace Videos {
  export type AsObject = {
    videosList: Array<Video.AsObject>,
  }
}

export class CreateVideoRequest extends jspb.Message {
  getVideo(): Video | undefined;
  setVideo(value?: Video): CreateVideoRequest;
  hasVideo(): boolean;
  clearVideo(): CreateVideoRequest;

  getIndexpath(): string;
  setIndexpath(value: string): CreateVideoRequest;

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

export namespace CreateVideoRequest {
  export type AsObject = {
    video?: Video.AsObject,
    indexpath: string,
  }
}

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

export namespace CreateVideoResponse {
  export type AsObject = {
  }
}

export class GetVideoByIdRequest extends jspb.Message {
  getVidoeid(): string;
  setVidoeid(value: string): GetVideoByIdRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetVideoByIdRequest;

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

export namespace GetVideoByIdRequest {
  export type AsObject = {
    vidoeid: string,
    indexpath: string,
  }
}

export class GetVideoByIdResponse extends jspb.Message {
  getVideo(): Video | undefined;
  setVideo(value?: Video): GetVideoByIdResponse;
  hasVideo(): boolean;
  clearVideo(): GetVideoByIdResponse;

  getFilespathsList(): Array<string>;
  setFilespathsList(value: Array<string>): GetVideoByIdResponse;
  clearFilespathsList(): GetVideoByIdResponse;
  addFilespaths(value: string, index?: number): GetVideoByIdResponse;

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

export namespace GetVideoByIdResponse {
  export type AsObject = {
    video?: Video.AsObject,
    filespathsList: Array<string>,
  }
}

export class DeleteVideoRequest extends jspb.Message {
  getVideoid(): string;
  setVideoid(value: string): DeleteVideoRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DeleteVideoRequest;

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

export namespace DeleteVideoRequest {
  export type AsObject = {
    videoid: string,
    indexpath: string,
  }
}

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

export namespace DeleteVideoResponse {
  export type AsObject = {
  }
}

export class UpdateVideoMetadataRequest extends jspb.Message {
  getVideo(): Video | undefined;
  setVideo(value?: Video): UpdateVideoMetadataRequest;
  hasVideo(): boolean;
  clearVideo(): UpdateVideoMetadataRequest;

  getIndexpath(): string;
  setIndexpath(value: string): UpdateVideoMetadataRequest;

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

export namespace UpdateVideoMetadataRequest {
  export type AsObject = {
    video?: Video.AsObject,
    indexpath: string,
  }
}

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

export namespace UpdateVideoMetadataResponse {
  export type AsObject = {
  }
}

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

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

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

  getType(): string;
  setType(value: string): Title;

  getYear(): number;
  setYear(value: number): Title;

  getRating(): number;
  setRating(value: number): Title;

  getRatingcount(): number;
  setRatingcount(value: number): Title;

  getDirectorsList(): Array<Person>;
  setDirectorsList(value: Array<Person>): Title;
  clearDirectorsList(): Title;
  addDirectors(value?: Person, index?: number): Person;

  getWritersList(): Array<Person>;
  setWritersList(value: Array<Person>): Title;
  clearWritersList(): Title;
  addWriters(value?: Person, index?: number): Person;

  getActorsList(): Array<Person>;
  setActorsList(value: Array<Person>): Title;
  clearActorsList(): Title;
  addActors(value?: Person, index?: number): Person;

  getGenresList(): Array<string>;
  setGenresList(value: Array<string>): Title;
  clearGenresList(): Title;
  addGenres(value: string, index?: number): Title;

  getLanguageList(): Array<string>;
  setLanguageList(value: Array<string>): Title;
  clearLanguageList(): Title;
  addLanguage(value: string, index?: number): Title;

  getNationalitiesList(): Array<string>;
  setNationalitiesList(value: Array<string>): Title;
  clearNationalitiesList(): Title;
  addNationalities(value: string, index?: number): Title;

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

  getPoster(): Poster | undefined;
  setPoster(value?: Poster): Title;
  hasPoster(): boolean;
  clearPoster(): Title;

  getAkaList(): Array<string>;
  setAkaList(value: Array<string>): Title;
  clearAkaList(): Title;
  addAka(value: string, index?: number): Title;

  getDuration(): string;
  setDuration(value: string): Title;

  getSeason(): number;
  setSeason(value: number): Title;

  getEpisode(): number;
  setEpisode(value: number): Title;

  getSerie(): string;
  setSerie(value: string): Title;

  getUuid(): string;
  setUuid(value: string): Title;

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

export namespace Title {
  export type AsObject = {
    id: string,
    url: string,
    name: string,
    type: string,
    year: number,
    rating: number,
    ratingcount: number,
    directorsList: Array<Person.AsObject>,
    writersList: Array<Person.AsObject>,
    actorsList: Array<Person.AsObject>,
    genresList: Array<string>,
    languageList: Array<string>,
    nationalitiesList: Array<string>,
    description: string,
    poster?: Poster.AsObject,
    akaList: Array<string>,
    duration: string,
    season: number,
    episode: number,
    serie: string,
    uuid: string,
  }
}

export class Titles extends jspb.Message {
  getTitlesList(): Array<Title>;
  setTitlesList(value: Array<Title>): Titles;
  clearTitlesList(): Titles;
  addTitles(value?: Title, index?: number): Title;

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

export namespace Titles {
  export type AsObject = {
    titlesList: Array<Title.AsObject>,
  }
}

export class CreateTitleRequest extends jspb.Message {
  getTitle(): Title | undefined;
  setTitle(value?: Title): CreateTitleRequest;
  hasTitle(): boolean;
  clearTitle(): CreateTitleRequest;

  getIndexpath(): string;
  setIndexpath(value: string): CreateTitleRequest;

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

export namespace CreateTitleRequest {
  export type AsObject = {
    title?: Title.AsObject,
    indexpath: string,
  }
}

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

export namespace CreateTitleResponse {
  export type AsObject = {
  }
}

export class GetTitleByIdRequest extends jspb.Message {
  getTitleid(): string;
  setTitleid(value: string): GetTitleByIdRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetTitleByIdRequest;

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

export namespace GetTitleByIdRequest {
  export type AsObject = {
    titleid: string,
    indexpath: string,
  }
}

export class GetTitleByIdResponse extends jspb.Message {
  getTitle(): Title | undefined;
  setTitle(value?: Title): GetTitleByIdResponse;
  hasTitle(): boolean;
  clearTitle(): GetTitleByIdResponse;

  getFilespathsList(): Array<string>;
  setFilespathsList(value: Array<string>): GetTitleByIdResponse;
  clearFilespathsList(): GetTitleByIdResponse;
  addFilespaths(value: string, index?: number): GetTitleByIdResponse;

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

export namespace GetTitleByIdResponse {
  export type AsObject = {
    title?: Title.AsObject,
    filespathsList: Array<string>,
  }
}

export class DeleteTitleRequest extends jspb.Message {
  getTitleid(): string;
  setTitleid(value: string): DeleteTitleRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DeleteTitleRequest;

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

export namespace DeleteTitleRequest {
  export type AsObject = {
    titleid: string,
    indexpath: string,
  }
}

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

export namespace DeleteTitleResponse {
  export type AsObject = {
  }
}

export class UpdateTitleMetadataRequest extends jspb.Message {
  getTitle(): Title | undefined;
  setTitle(value?: Title): UpdateTitleMetadataRequest;
  hasTitle(): boolean;
  clearTitle(): UpdateTitleMetadataRequest;

  getIndexpath(): string;
  setIndexpath(value: string): UpdateTitleMetadataRequest;

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

export namespace UpdateTitleMetadataRequest {
  export type AsObject = {
    title?: Title.AsObject,
    indexpath: string,
  }
}

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

export namespace UpdateTitleMetadataResponse {
  export type AsObject = {
  }
}

export class AssociateFileWithTitleRequest extends jspb.Message {
  getTitleid(): string;
  setTitleid(value: string): AssociateFileWithTitleRequest;

  getFilepath(): string;
  setFilepath(value: string): AssociateFileWithTitleRequest;

  getIndexpath(): string;
  setIndexpath(value: string): AssociateFileWithTitleRequest;

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

export namespace AssociateFileWithTitleRequest {
  export type AsObject = {
    titleid: string,
    filepath: string,
    indexpath: string,
  }
}

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

export namespace AssociateFileWithTitleResponse {
  export type AsObject = {
  }
}

export class DissociateFileWithTitleRequest extends jspb.Message {
  getTitleid(): string;
  setTitleid(value: string): DissociateFileWithTitleRequest;

  getFilepath(): string;
  setFilepath(value: string): DissociateFileWithTitleRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DissociateFileWithTitleRequest;

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

export namespace DissociateFileWithTitleRequest {
  export type AsObject = {
    titleid: string,
    filepath: string,
    indexpath: string,
  }
}

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

export namespace DissociateFileWithTitleResponse {
  export type AsObject = {
  }
}

export class GetFileTitlesRequest extends jspb.Message {
  getFilepath(): string;
  setFilepath(value: string): GetFileTitlesRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetFileTitlesRequest;

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

export namespace GetFileTitlesRequest {
  export type AsObject = {
    filepath: string,
    indexpath: string,
  }
}

export class GetFileTitlesResponse extends jspb.Message {
  getTitles(): Titles | undefined;
  setTitles(value?: Titles): GetFileTitlesResponse;
  hasTitles(): boolean;
  clearTitles(): GetFileTitlesResponse;

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

export namespace GetFileTitlesResponse {
  export type AsObject = {
    titles?: Titles.AsObject,
  }
}

export class GetFileVideosRequest extends jspb.Message {
  getFilepath(): string;
  setFilepath(value: string): GetFileVideosRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetFileVideosRequest;

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

export namespace GetFileVideosRequest {
  export type AsObject = {
    filepath: string,
    indexpath: string,
  }
}

export class GetFileVideosResponse extends jspb.Message {
  getVideos(): Videos | undefined;
  setVideos(value?: Videos): GetFileVideosResponse;
  hasVideos(): boolean;
  clearVideos(): GetFileVideosResponse;

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

export namespace GetFileVideosResponse {
  export type AsObject = {
    videos?: Videos.AsObject,
  }
}

export class GetTitleFilesRequest extends jspb.Message {
  getTitleid(): string;
  setTitleid(value: string): GetTitleFilesRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetTitleFilesRequest;

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

export namespace GetTitleFilesRequest {
  export type AsObject = {
    titleid: string,
    indexpath: string,
  }
}

export class GetTitleFilesResponse extends jspb.Message {
  getFilepathsList(): Array<string>;
  setFilepathsList(value: Array<string>): GetTitleFilesResponse;
  clearFilepathsList(): GetTitleFilesResponse;
  addFilepaths(value: string, index?: number): GetTitleFilesResponse;

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

export namespace GetTitleFilesResponse {
  export type AsObject = {
    filepathsList: Array<string>,
  }
}

export class Snippet extends jspb.Message {
  getField(): string;
  setField(value: string): Snippet;

  getFragmentsList(): Array<string>;
  setFragmentsList(value: Array<string>): Snippet;
  clearFragmentsList(): Snippet;
  addFragments(value: string, index?: number): Snippet;

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

export namespace Snippet {
  export type AsObject = {
    field: string,
    fragmentsList: Array<string>,
  }
}

export class SearchHit extends jspb.Message {
  getIndex(): number;
  setIndex(value: number): SearchHit;

  getScore(): number;
  setScore(value: number): SearchHit;

  getSnippetsList(): Array<Snippet>;
  setSnippetsList(value: Array<Snippet>): SearchHit;
  clearSnippetsList(): SearchHit;
  addSnippets(value?: Snippet, index?: number): Snippet;

  getTitle(): Title | undefined;
  setTitle(value?: Title): SearchHit;
  hasTitle(): boolean;
  clearTitle(): SearchHit;

  getVideo(): Video | undefined;
  setVideo(value?: Video): SearchHit;
  hasVideo(): boolean;
  clearVideo(): SearchHit;

  getAudio(): Audio | undefined;
  setAudio(value?: Audio): SearchHit;
  hasAudio(): boolean;
  clearAudio(): SearchHit;

  getPerson(): Person | undefined;
  setPerson(value?: Person): SearchHit;
  hasPerson(): boolean;
  clearPerson(): SearchHit;

  getResultCase(): SearchHit.ResultCase;

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

export namespace SearchHit {
  export type AsObject = {
    index: number,
    score: number,
    snippetsList: Array<Snippet.AsObject>,
    title?: Title.AsObject,
    video?: Video.AsObject,
    audio?: Audio.AsObject,
    person?: Person.AsObject,
  }

  export enum ResultCase { 
    RESULT_NOT_SET = 0,
    TITLE = 4,
    VIDEO = 5,
    AUDIO = 6,
    PERSON = 7,
  }
}

export class SearchSummary extends jspb.Message {
  getQuery(): string;
  setQuery(value: string): SearchSummary;

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

  getTook(): number;
  setTook(value: number): SearchSummary;

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

export namespace SearchSummary {
  export type AsObject = {
    query: string,
    total: number,
    took: number,
  }
}

export class SearchFacetTerm extends jspb.Message {
  getTerm(): string;
  setTerm(value: string): SearchFacetTerm;

  getCount(): number;
  setCount(value: number): SearchFacetTerm;

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

export namespace SearchFacetTerm {
  export type AsObject = {
    term: string,
    count: number,
  }
}

export class SearchFacet extends jspb.Message {
  getField(): string;
  setField(value: string): SearchFacet;

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

  getTermsList(): Array<SearchFacetTerm>;
  setTermsList(value: Array<SearchFacetTerm>): SearchFacet;
  clearTermsList(): SearchFacet;
  addTerms(value?: SearchFacetTerm, index?: number): SearchFacetTerm;

  getOther(): number;
  setOther(value: number): SearchFacet;

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

export namespace SearchFacet {
  export type AsObject = {
    field: string,
    total: number,
    termsList: Array<SearchFacetTerm.AsObject>,
    other: number,
  }
}

export class SearchFacets extends jspb.Message {
  getFacetsList(): Array<SearchFacet>;
  setFacetsList(value: Array<SearchFacet>): SearchFacets;
  clearFacetsList(): SearchFacets;
  addFacets(value?: SearchFacet, index?: number): SearchFacet;

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

export namespace SearchFacets {
  export type AsObject = {
    facetsList: Array<SearchFacet.AsObject>,
  }
}

export class SearchTitlesRequest extends jspb.Message {
  getQuery(): string;
  setQuery(value: string): SearchTitlesRequest;

  getFieldsList(): Array<string>;
  setFieldsList(value: Array<string>): SearchTitlesRequest;
  clearFieldsList(): SearchTitlesRequest;
  addFields(value: string, index?: number): SearchTitlesRequest;

  getIndexpath(): string;
  setIndexpath(value: string): SearchTitlesRequest;

  getSize(): number;
  setSize(value: number): SearchTitlesRequest;

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

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

export namespace SearchTitlesRequest {
  export type AsObject = {
    query: string,
    fieldsList: Array<string>,
    indexpath: string,
    size: number,
    offset: number,
  }
}

export class SearchTitlesResponse extends jspb.Message {
  getSummary(): SearchSummary | undefined;
  setSummary(value?: SearchSummary): SearchTitlesResponse;
  hasSummary(): boolean;
  clearSummary(): SearchTitlesResponse;

  getHit(): SearchHit | undefined;
  setHit(value?: SearchHit): SearchTitlesResponse;
  hasHit(): boolean;
  clearHit(): SearchTitlesResponse;

  getFacets(): SearchFacets | undefined;
  setFacets(value?: SearchFacets): SearchTitlesResponse;
  hasFacets(): boolean;
  clearFacets(): SearchTitlesResponse;

  getResultCase(): SearchTitlesResponse.ResultCase;

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

export namespace SearchTitlesResponse {
  export type AsObject = {
    summary?: SearchSummary.AsObject,
    hit?: SearchHit.AsObject,
    facets?: SearchFacets.AsObject,
  }

  export enum ResultCase { 
    RESULT_NOT_SET = 0,
    SUMMARY = 1,
    HIT = 2,
    FACETS = 3,
  }
}

export class SearchPersonsRequest extends jspb.Message {
  getQuery(): string;
  setQuery(value: string): SearchPersonsRequest;

  getFieldsList(): Array<string>;
  setFieldsList(value: Array<string>): SearchPersonsRequest;
  clearFieldsList(): SearchPersonsRequest;
  addFields(value: string, index?: number): SearchPersonsRequest;

  getIndexpath(): string;
  setIndexpath(value: string): SearchPersonsRequest;

  getSize(): number;
  setSize(value: number): SearchPersonsRequest;

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

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

export namespace SearchPersonsRequest {
  export type AsObject = {
    query: string,
    fieldsList: Array<string>,
    indexpath: string,
    size: number,
    offset: number,
  }
}

export class SearchPersonsResponse extends jspb.Message {
  getSummary(): SearchSummary | undefined;
  setSummary(value?: SearchSummary): SearchPersonsResponse;
  hasSummary(): boolean;
  clearSummary(): SearchPersonsResponse;

  getHit(): SearchHit | undefined;
  setHit(value?: SearchHit): SearchPersonsResponse;
  hasHit(): boolean;
  clearHit(): SearchPersonsResponse;

  getFacets(): SearchFacets | undefined;
  setFacets(value?: SearchFacets): SearchPersonsResponse;
  hasFacets(): boolean;
  clearFacets(): SearchPersonsResponse;

  getResultCase(): SearchPersonsResponse.ResultCase;

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

export namespace SearchPersonsResponse {
  export type AsObject = {
    summary?: SearchSummary.AsObject,
    hit?: SearchHit.AsObject,
    facets?: SearchFacets.AsObject,
  }

  export enum ResultCase { 
    RESULT_NOT_SET = 0,
    SUMMARY = 1,
    HIT = 2,
    FACETS = 3,
  }
}

export class CreatePublisherRequest extends jspb.Message {
  getPublisher(): Publisher | undefined;
  setPublisher(value?: Publisher): CreatePublisherRequest;
  hasPublisher(): boolean;
  clearPublisher(): CreatePublisherRequest;

  getIndexpath(): string;
  setIndexpath(value: string): CreatePublisherRequest;

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

export namespace CreatePublisherRequest {
  export type AsObject = {
    publisher?: Publisher.AsObject,
    indexpath: string,
  }
}

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

export namespace CreatePublisherResponse {
  export type AsObject = {
  }
}

export class DeletePublisherRequest extends jspb.Message {
  getPublisherid(): string;
  setPublisherid(value: string): DeletePublisherRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DeletePublisherRequest;

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

export namespace DeletePublisherRequest {
  export type AsObject = {
    publisherid: string,
    indexpath: string,
  }
}

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

export namespace DeletePublisherResponse {
  export type AsObject = {
  }
}

export class GetPublisherByIdRequest extends jspb.Message {
  getPublisherid(): string;
  setPublisherid(value: string): GetPublisherByIdRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetPublisherByIdRequest;

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

export namespace GetPublisherByIdRequest {
  export type AsObject = {
    publisherid: string,
    indexpath: string,
  }
}

export class GetPublisherByIdResponse extends jspb.Message {
  getPublisher(): Publisher | undefined;
  setPublisher(value?: Publisher): GetPublisherByIdResponse;
  hasPublisher(): boolean;
  clearPublisher(): GetPublisherByIdResponse;

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

export namespace GetPublisherByIdResponse {
  export type AsObject = {
    publisher?: Publisher.AsObject,
  }
}

export class CreatePersonRequest extends jspb.Message {
  getPerson(): Person | undefined;
  setPerson(value?: Person): CreatePersonRequest;
  hasPerson(): boolean;
  clearPerson(): CreatePersonRequest;

  getIndexpath(): string;
  setIndexpath(value: string): CreatePersonRequest;

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

export namespace CreatePersonRequest {
  export type AsObject = {
    person?: Person.AsObject,
    indexpath: string,
  }
}

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

export namespace CreatePersonResponse {
  export type AsObject = {
  }
}

export class DeletePersonRequest extends jspb.Message {
  getPersonid(): string;
  setPersonid(value: string): DeletePersonRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DeletePersonRequest;

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

export namespace DeletePersonRequest {
  export type AsObject = {
    personid: string,
    indexpath: string,
  }
}

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

export namespace DeletePersonResponse {
  export type AsObject = {
  }
}

export class GetPersonByIdRequest extends jspb.Message {
  getPersonid(): string;
  setPersonid(value: string): GetPersonByIdRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetPersonByIdRequest;

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

export namespace GetPersonByIdRequest {
  export type AsObject = {
    personid: string,
    indexpath: string,
  }
}

export class GetPersonByIdResponse extends jspb.Message {
  getPerson(): Person | undefined;
  setPerson(value?: Person): GetPersonByIdResponse;
  hasPerson(): boolean;
  clearPerson(): GetPersonByIdResponse;

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

export namespace GetPersonByIdResponse {
  export type AsObject = {
    person?: Person.AsObject,
  }
}

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

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

  getArtist(): string;
  setArtist(value: string): Audio;

  getAlbumartist(): string;
  setAlbumartist(value: string): Audio;

  getAlbum(): string;
  setAlbum(value: string): Audio;

  getComment(): string;
  setComment(value: string): Audio;

  getComposer(): string;
  setComposer(value: string): Audio;

  getGenresList(): Array<string>;
  setGenresList(value: Array<string>): Audio;
  clearGenresList(): Audio;
  addGenres(value: string, index?: number): Audio;

  getLyrics(): string;
  setLyrics(value: string): Audio;

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

  getYear(): number;
  setYear(value: number): Audio;

  getDiscnumber(): number;
  setDiscnumber(value: number): Audio;

  getDisctotal(): number;
  setDisctotal(value: number): Audio;

  getTracknumber(): number;
  setTracknumber(value: number): Audio;

  getTracktotal(): number;
  setTracktotal(value: number): Audio;

  getPoster(): Poster | undefined;
  setPoster(value?: Poster): Audio;
  hasPoster(): boolean;
  clearPoster(): Audio;

  getDuration(): number;
  setDuration(value: number): Audio;

  getUuid(): string;
  setUuid(value: string): Audio;

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

export namespace Audio {
  export type AsObject = {
    id: string,
    url: string,
    artist: string,
    albumartist: string,
    album: string,
    comment: string,
    composer: string,
    genresList: Array<string>,
    lyrics: string,
    title: string,
    year: number,
    discnumber: number,
    disctotal: number,
    tracknumber: number,
    tracktotal: number,
    poster?: Poster.AsObject,
    duration: number,
    uuid: string,
  }
}

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

  getArtist(): string;
  setArtist(value: string): Album;

  getYear(): number;
  setYear(value: number): Album;

  getGenresList(): Array<string>;
  setGenresList(value: Array<string>): Album;
  clearGenresList(): Album;
  addGenres(value: string, index?: number): Album;

  getTracks(): Audios | undefined;
  setTracks(value?: Audios): Album;
  hasTracks(): boolean;
  clearTracks(): Album;

  getPoster(): Poster | undefined;
  setPoster(value?: Poster): Album;
  hasPoster(): boolean;
  clearPoster(): Album;

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

export namespace Album {
  export type AsObject = {
    id: string,
    artist: string,
    year: number,
    genresList: Array<string>,
    tracks?: Audios.AsObject,
    poster?: Poster.AsObject,
  }
}

export class Audios extends jspb.Message {
  getAudiosList(): Array<Audio>;
  setAudiosList(value: Array<Audio>): Audios;
  clearAudiosList(): Audios;
  addAudios(value?: Audio, index?: number): Audio;

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

export namespace Audios {
  export type AsObject = {
    audiosList: Array<Audio.AsObject>,
  }
}

export class CreateAudioRequest extends jspb.Message {
  getAudio(): Audio | undefined;
  setAudio(value?: Audio): CreateAudioRequest;
  hasAudio(): boolean;
  clearAudio(): CreateAudioRequest;

  getIndexpath(): string;
  setIndexpath(value: string): CreateAudioRequest;

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

export namespace CreateAudioRequest {
  export type AsObject = {
    audio?: Audio.AsObject,
    indexpath: string,
  }
}

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

export namespace CreateAudioResponse {
  export type AsObject = {
  }
}

export class GetAudioByIdRequest extends jspb.Message {
  getAudioid(): string;
  setAudioid(value: string): GetAudioByIdRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetAudioByIdRequest;

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

export namespace GetAudioByIdRequest {
  export type AsObject = {
    audioid: string,
    indexpath: string,
  }
}

export class GetAudioByIdResponse extends jspb.Message {
  getAudio(): Audio | undefined;
  setAudio(value?: Audio): GetAudioByIdResponse;
  hasAudio(): boolean;
  clearAudio(): GetAudioByIdResponse;

  getFilespathsList(): Array<string>;
  setFilespathsList(value: Array<string>): GetAudioByIdResponse;
  clearFilespathsList(): GetAudioByIdResponse;
  addFilespaths(value: string, index?: number): GetAudioByIdResponse;

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

export namespace GetAudioByIdResponse {
  export type AsObject = {
    audio?: Audio.AsObject,
    filespathsList: Array<string>,
  }
}

export class DeleteAudioRequest extends jspb.Message {
  getAudioid(): string;
  setAudioid(value: string): DeleteAudioRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DeleteAudioRequest;

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

export namespace DeleteAudioRequest {
  export type AsObject = {
    audioid: string,
    indexpath: string,
  }
}

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

export namespace DeleteAudioResponse {
  export type AsObject = {
  }
}

export class GetFileAudiosRequest extends jspb.Message {
  getFilepath(): string;
  setFilepath(value: string): GetFileAudiosRequest;

  getIndexpath(): string;
  setIndexpath(value: string): GetFileAudiosRequest;

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

export namespace GetFileAudiosRequest {
  export type AsObject = {
    filepath: string,
    indexpath: string,
  }
}

export class GetFileAudiosResponse extends jspb.Message {
  getAudios(): Audios | undefined;
  setAudios(value?: Audios): GetFileAudiosResponse;
  hasAudios(): boolean;
  clearAudios(): GetFileAudiosResponse;

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

export namespace GetFileAudiosResponse {
  export type AsObject = {
    audios?: Audios.AsObject,
  }
}

export class GetAlbumRequest extends jspb.Message {
  getAlbumid(): string;
  setAlbumid(value: string): GetAlbumRequest;

  getIndexpath(): string;
  setIndexpath(value: string): 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: string,
    indexpath: string,
  }
}

export class GetAlbumResponse extends jspb.Message {
  getAlbum(): Album | undefined;
  setAlbum(value?: 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?: Album.AsObject,
  }
}

export class DeleteAlbumRequest extends jspb.Message {
  getAlbumid(): string;
  setAlbumid(value: string): DeleteAlbumRequest;

  getIndexpath(): string;
  setIndexpath(value: string): DeleteAlbumRequest;

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

export namespace DeleteAlbumRequest {
  export type AsObject = {
    albumid: string,
    indexpath: string,
  }
}

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

export namespace DeleteAlbumResponse {
  export type AsObject = {
  }
}