import * as jspb from 'google-protobuf'

import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb'; // proto import: "google/protobuf/empty.proto"
import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb'; // proto import: "google/protobuf/timestamp.proto"
import * as google_protobuf_wrappers_pb from 'google-protobuf/google/protobuf/wrappers_pb'; // proto import: "google/protobuf/wrappers.proto"
import * as annotations_pb from './annotations_pb'; // proto import: "annotations.proto"
import * as api_pb from './api_pb'; // proto import: "api.proto"


export class AdminActionLog extends jspb.Message {
  getAdminActionId(): number;
  setAdminActionId(value: number): AdminActionLog;

  getCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreated(value?: google_protobuf_timestamp_pb.Timestamp): AdminActionLog;
  hasCreated(): boolean;
  clearCreated(): AdminActionLog;

  getAdminUserId(): number;
  setAdminUserId(value: number): AdminActionLog;

  getAdminUsername(): string;
  setAdminUsername(value: string): AdminActionLog;

  getActionType(): string;
  setActionType(value: string): AdminActionLog;

  getNote(): string;
  setNote(value: string): AdminActionLog;

  getTag(): string;
  setTag(value: string): AdminActionLog;

  getLevel(): AdminActionLevel;
  setLevel(value: AdminActionLevel): AdminActionLog;

  getTargetUserId(): number;
  setTargetUserId(value: number): AdminActionLog;

  getTargetUsername(): string;
  setTargetUsername(value: string): AdminActionLog;

  getData(): string;
  setData(value: string): AdminActionLog;

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

export namespace AdminActionLog {
  export type AsObject = {
    adminActionId: number,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    adminUserId: number,
    adminUsername: string,
    actionType: string,
    note: string,
    tag: string,
    level: AdminActionLevel,
    targetUserId: number,
    targetUsername: string,
    data: string,
  }
}

export class AdminTagInfo extends jspb.Message {
  getAdminTagId(): number;
  setAdminTagId(value: number): AdminTagInfo;

  getTag(): string;
  setTag(value: string): AdminTagInfo;

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

export namespace AdminTagInfo {
  export type AsObject = {
    adminTagId: number,
    tag: string,
  }
}

export class UserDetails extends jspb.Message {
  getUserId(): number;
  setUserId(value: number): UserDetails;

  getUsername(): string;
  setUsername(value: string): UserDetails;

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

  getEmail(): string;
  setEmail(value: string): UserDetails;

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

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

  getBanned(): boolean;
  setBanned(value: boolean): UserDetails;

  getDeleted(): boolean;
  setDeleted(value: boolean): UserDetails;

  getShadowed(): boolean;
  setShadowed(value: boolean): UserDetails;

  getDoNotEmail(): boolean;
  setDoNotEmail(value: boolean): UserDetails;

  getBadgesList(): Array<string>;
  setBadgesList(value: Array<string>): UserDetails;
  clearBadgesList(): UserDetails;
  addBadges(value: string, index?: number): UserDetails;

  getHasStrongVerification(): boolean;
  setHasStrongVerification(value: boolean): UserDetails;

  getBirthdateVerificationStatus(): api_pb.BirthdateVerificationStatus;
  setBirthdateVerificationStatus(value: api_pb.BirthdateVerificationStatus): UserDetails;

  getGenderVerificationStatus(): api_pb.GenderVerificationStatus;
  setGenderVerificationStatus(value: api_pb.GenderVerificationStatus): UserDetails;

  getHasPassportSexGenderException(): boolean;
  setHasPassportSexGenderException(value: boolean): UserDetails;

  getPendingModNotesCount(): number;
  setPendingModNotesCount(value: number): UserDetails;

  getAcknowledgedModNotesCount(): number;
  setAcknowledgedModNotesCount(value: number): UserDetails;

  getLastModNoteAcknowledged(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setLastModNoteAcknowledged(value?: google_protobuf_timestamp_pb.Timestamp): UserDetails;
  hasLastModNoteAcknowledged(): boolean;
  clearLastModNoteAcknowledged(): UserDetails;

  getAdminActionsList(): Array<AdminActionLog>;
  setAdminActionsList(value: Array<AdminActionLog>): UserDetails;
  clearAdminActionsList(): UserDetails;
  addAdminActions(value?: AdminActionLog, index?: number): AdminActionLog;

  getAdminTagsList(): Array<string>;
  setAdminTagsList(value: Array<string>): UserDetails;
  clearAdminTagsList(): UserDetails;
  addAdminTags(value: string, index?: number): UserDetails;

  getModScore(): number;
  setModScore(value: number): UserDetails;

  getUiLanguagePreference(): string;
  setUiLanguagePreference(value: string): UserDetails;

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

export namespace UserDetails {
  export type AsObject = {
    userId: number,
    username: string,
    name: string,
    email: string,
    gender: string,
    birthdate: string,
    banned: boolean,
    deleted: boolean,
    shadowed: boolean,
    doNotEmail: boolean,
    badgesList: Array<string>,
    hasStrongVerification: boolean,
    birthdateVerificationStatus: api_pb.BirthdateVerificationStatus,
    genderVerificationStatus: api_pb.GenderVerificationStatus,
    hasPassportSexGenderException: boolean,
    pendingModNotesCount: number,
    acknowledgedModNotesCount: number,
    lastModNoteAcknowledged?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    adminActionsList: Array<AdminActionLog.AsObject>,
    adminTagsList: Array<string>,
    modScore: number,
    uiLanguagePreference: string,
  }
}

export class GetUserDetailsReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetUserDetailsReq;

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

export namespace GetUserDetailsReq {
  export type AsObject = {
    user: string,
  }
}

export class GetUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetUserReq;

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

export namespace GetUserReq {
  export type AsObject = {
    user: string,
  }
}

export class SearchUsersReq extends jspb.Message {
  getUsername(): string;
  setUsername(value: string): SearchUsersReq;

  getEmail(): string;
  setEmail(value: string): SearchUsersReq;

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

  getAdminActionLog(): string;
  setAdminActionLog(value: string): SearchUsersReq;

  getCity(): string;
  setCity(value: string): SearchUsersReq;

  getMinUserId(): number;
  setMinUserId(value: number): SearchUsersReq;

  getMaxUserId(): number;
  setMaxUserId(value: number): SearchUsersReq;

  getMinBirthdate(): string;
  setMinBirthdate(value: string): SearchUsersReq;

  getMaxBirthdate(): string;
  setMaxBirthdate(value: string): SearchUsersReq;

  getMinJoinedDate(): string;
  setMinJoinedDate(value: string): SearchUsersReq;

  getMaxJoinedDate(): string;
  setMaxJoinedDate(value: string): SearchUsersReq;

  getMinLastActiveDate(): string;
  setMinLastActiveDate(value: string): SearchUsersReq;

  getMaxLastActiveDate(): string;
  setMaxLastActiveDate(value: string): SearchUsersReq;

  getGendersList(): Array<string>;
  setGendersList(value: Array<string>): SearchUsersReq;
  clearGendersList(): SearchUsersReq;
  addGenders(value: string, index?: number): SearchUsersReq;

  getLanguageCodesList(): Array<string>;
  setLanguageCodesList(value: Array<string>): SearchUsersReq;
  clearLanguageCodesList(): SearchUsersReq;
  addLanguageCodes(value: string, index?: number): SearchUsersReq;

  getIsDeleted(): google_protobuf_wrappers_pb.BoolValue | undefined;
  setIsDeleted(value?: google_protobuf_wrappers_pb.BoolValue): SearchUsersReq;
  hasIsDeleted(): boolean;
  clearIsDeleted(): SearchUsersReq;

  getIsBanned(): google_protobuf_wrappers_pb.BoolValue | undefined;
  setIsBanned(value?: google_protobuf_wrappers_pb.BoolValue): SearchUsersReq;
  hasIsBanned(): boolean;
  clearIsBanned(): SearchUsersReq;

  getIsShadowed(): google_protobuf_wrappers_pb.BoolValue | undefined;
  setIsShadowed(value?: google_protobuf_wrappers_pb.BoolValue): SearchUsersReq;
  hasIsShadowed(): boolean;
  clearIsShadowed(): SearchUsersReq;

  getHasAvatar(): google_protobuf_wrappers_pb.BoolValue | undefined;
  setHasAvatar(value?: google_protobuf_wrappers_pb.BoolValue): SearchUsersReq;
  hasHasAvatar(): boolean;
  clearHasAvatar(): SearchUsersReq;

  getAdminTagsList(): Array<string>;
  setAdminTagsList(value: Array<string>): SearchUsersReq;
  clearAdminTagsList(): SearchUsersReq;
  addAdminTags(value: string, index?: number): SearchUsersReq;

  getPageSize(): number;
  setPageSize(value: number): SearchUsersReq;

  getPageToken(): string;
  setPageToken(value: string): SearchUsersReq;

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

export namespace SearchUsersReq {
  export type AsObject = {
    username: string,
    email: string,
    name: string,
    adminActionLog: string,
    city: string,
    minUserId: number,
    maxUserId: number,
    minBirthdate: string,
    maxBirthdate: string,
    minJoinedDate: string,
    maxJoinedDate: string,
    minLastActiveDate: string,
    maxLastActiveDate: string,
    gendersList: Array<string>,
    languageCodesList: Array<string>,
    isDeleted?: google_protobuf_wrappers_pb.BoolValue.AsObject,
    isBanned?: google_protobuf_wrappers_pb.BoolValue.AsObject,
    isShadowed?: google_protobuf_wrappers_pb.BoolValue.AsObject,
    hasAvatar?: google_protobuf_wrappers_pb.BoolValue.AsObject,
    adminTagsList: Array<string>,
    pageSize: number,
    pageToken: string,
  }
}

export class SearchUsersRes extends jspb.Message {
  getUsersList(): Array<UserDetails>;
  setUsersList(value: Array<UserDetails>): SearchUsersRes;
  clearUsersList(): SearchUsersRes;
  addUsers(value?: UserDetails, index?: number): UserDetails;

  getNextPageToken(): string;
  setNextPageToken(value: string): SearchUsersRes;

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

export namespace SearchUsersRes {
  export type AsObject = {
    usersList: Array<UserDetails.AsObject>,
    nextPageToken: string,
  }
}

export class ChangeUserGenderReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): ChangeUserGenderReq;

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

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

export namespace ChangeUserGenderReq {
  export type AsObject = {
    user: string,
    gender: string,
  }
}

export class ChangeUserBirthdateReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): ChangeUserBirthdateReq;

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

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

export namespace ChangeUserBirthdateReq {
  export type AsObject = {
    user: string,
    birthdate: string,
  }
}

export class AddBadgeReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): AddBadgeReq;

  getBadgeId(): string;
  setBadgeId(value: string): AddBadgeReq;

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

export namespace AddBadgeReq {
  export type AsObject = {
    user: string,
    badgeId: string,
  }
}

export class RemoveBadgeReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): RemoveBadgeReq;

  getBadgeId(): string;
  setBadgeId(value: string): RemoveBadgeReq;

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

export namespace RemoveBadgeReq {
  export type AsObject = {
    user: string,
    badgeId: string,
  }
}

export class SetPassportSexGenderExceptionReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): SetPassportSexGenderExceptionReq;

  getPassportSexGenderException(): boolean;
  setPassportSexGenderException(value: boolean): SetPassportSexGenderExceptionReq;

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

export namespace SetPassportSexGenderExceptionReq {
  export type AsObject = {
    user: string,
    passportSexGenderException: boolean,
  }
}

export class BanUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): BanUserReq;

  getAdminNote(): string;
  setAdminNote(value: string): BanUserReq;

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

export namespace BanUserReq {
  export type AsObject = {
    user: string,
    adminNote: string,
  }
}

export class UnbanUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): UnbanUserReq;

  getAdminNote(): string;
  setAdminNote(value: string): UnbanUserReq;

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

export namespace UnbanUserReq {
  export type AsObject = {
    user: string,
    adminNote: string,
  }
}

export class ShadowUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): ShadowUserReq;

  getAdminNote(): string;
  setAdminNote(value: string): ShadowUserReq;

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

export namespace ShadowUserReq {
  export type AsObject = {
    user: string,
    adminNote: string,
  }
}

export class UnshadowUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): UnshadowUserReq;

  getAdminNote(): string;
  setAdminNote(value: string): UnshadowUserReq;

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

export namespace UnshadowUserReq {
  export type AsObject = {
    user: string,
    adminNote: string,
  }
}

export class AddAdminNoteReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): AddAdminNoteReq;

  getAdminNote(): string;
  setAdminNote(value: string): AddAdminNoteReq;

  getLevel(): AdminActionLevel;
  setLevel(value: AdminActionLevel): AddAdminNoteReq;

  getData(): string;
  setData(value: string): AddAdminNoteReq;

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

export namespace AddAdminNoteReq {
  export type AsObject = {
    user: string,
    adminNote: string,
    level: AdminActionLevel,
    data: string,
  }
}

export class ContentReport extends jspb.Message {
  getContentReportId(): number;
  setContentReportId(value: number): ContentReport;

  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): ContentReport;
  hasTime(): boolean;
  clearTime(): ContentReport;

  getReportingUserId(): number;
  setReportingUserId(value: number): ContentReport;

  getAuthorUserId(): number;
  setAuthorUserId(value: number): ContentReport;

  getReason(): string;
  setReason(value: string): ContentReport;

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

  getContentRef(): string;
  setContentRef(value: string): ContentReport;

  getUserAgent(): string;
  setUserAgent(value: string): ContentReport;

  getPage(): string;
  setPage(value: string): ContentReport;

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

export namespace ContentReport {
  export type AsObject = {
    contentReportId: number,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    reportingUserId: number,
    authorUserId: number,
    reason: string,
    description: string,
    contentRef: string,
    userAgent: string,
    page: string,
  }
}

export class GetContentReportReq extends jspb.Message {
  getContentReportId(): number;
  setContentReportId(value: number): GetContentReportReq;

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

export namespace GetContentReportReq {
  export type AsObject = {
    contentReportId: number,
  }
}

export class GetContentReportRes extends jspb.Message {
  getContentReport(): ContentReport | undefined;
  setContentReport(value?: ContentReport): GetContentReportRes;
  hasContentReport(): boolean;
  clearContentReport(): GetContentReportRes;

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

export namespace GetContentReportRes {
  export type AsObject = {
    contentReport?: ContentReport.AsObject,
  }
}

export class GetContentReportsForAuthorReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetContentReportsForAuthorReq;

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

export namespace GetContentReportsForAuthorReq {
  export type AsObject = {
    user: string,
  }
}

export class GetContentReportsForAuthorRes extends jspb.Message {
  getContentReportsList(): Array<ContentReport>;
  setContentReportsList(value: Array<ContentReport>): GetContentReportsForAuthorRes;
  clearContentReportsList(): GetContentReportsForAuthorRes;
  addContentReports(value?: ContentReport, index?: number): ContentReport;

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

export namespace GetContentReportsForAuthorRes {
  export type AsObject = {
    contentReportsList: Array<ContentReport.AsObject>,
  }
}

export class SendModNoteReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): SendModNoteReq;

  getContent(): string;
  setContent(value: string): SendModNoteReq;

  getInternalId(): string;
  setInternalId(value: string): SendModNoteReq;

  getDoNotNotify(): boolean;
  setDoNotNotify(value: boolean): SendModNoteReq;

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

export namespace SendModNoteReq {
  export type AsObject = {
    user: string,
    content: string,
    internalId: string,
    doNotNotify: boolean,
  }
}

export class MarkUserNeedsLocationUpdateReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): MarkUserNeedsLocationUpdateReq;

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

export namespace MarkUserNeedsLocationUpdateReq {
  export type AsObject = {
    user: string,
  }
}

export class DeleteUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): DeleteUserReq;

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

export namespace DeleteUserReq {
  export type AsObject = {
    user: string,
  }
}

export class RecoverDeletedUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): RecoverDeletedUserReq;

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

export namespace RecoverDeletedUserReq {
  export type AsObject = {
    user: string,
  }
}

export class CreateApiKeyReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): CreateApiKeyReq;

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

export namespace CreateApiKeyReq {
  export type AsObject = {
    user: string,
  }
}

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

export namespace CreateApiKeyRes {
  export type AsObject = {
  }
}

export class GetChatsReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetChatsReq;

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

export namespace GetChatsReq {
  export type AsObject = {
    user: string,
  }
}

export class ChatUserInfo extends jspb.Message {
  getUserId(): number;
  setUserId(value: number): ChatUserInfo;

  getUsername(): string;
  setUsername(value: string): ChatUserInfo;

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

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

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

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

export namespace ChatUserInfo {
  export type AsObject = {
    userId: number,
    username: string,
    name: string,
    birthdate: string,
    gender: string,
  }
}

export class ChatMessage extends jspb.Message {
  getMessageId(): number;
  setMessageId(value: number): ChatMessage;

  getAuthor(): ChatUserInfo | undefined;
  setAuthor(value?: ChatUserInfo): ChatMessage;
  hasAuthor(): boolean;
  clearAuthor(): ChatMessage;

  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): ChatMessage;
  hasTime(): boolean;
  clearTime(): ChatMessage;

  getMessageType(): string;
  setMessageType(value: string): ChatMessage;

  getText(): string;
  setText(value: string): ChatMessage;

  getHostRequestStatusTarget(): string;
  setHostRequestStatusTarget(value: string): ChatMessage;

  getTarget(): ChatUserInfo | undefined;
  setTarget(value?: ChatUserInfo): ChatMessage;
  hasTarget(): boolean;
  clearTarget(): ChatMessage;

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

export namespace ChatMessage {
  export type AsObject = {
    messageId: number,
    author?: ChatUserInfo.AsObject,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    messageType: string,
    text: string,
    hostRequestStatusTarget: string,
    target?: ChatUserInfo.AsObject,
  }
}

export class GroupChatMember extends jspb.Message {
  getUser(): ChatUserInfo | undefined;
  setUser(value?: ChatUserInfo): GroupChatMember;
  hasUser(): boolean;
  clearUser(): GroupChatMember;

  getJoined(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setJoined(value?: google_protobuf_timestamp_pb.Timestamp): GroupChatMember;
  hasJoined(): boolean;
  clearJoined(): GroupChatMember;

  getLeft(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setLeft(value?: google_protobuf_timestamp_pb.Timestamp): GroupChatMember;
  hasLeft(): boolean;
  clearLeft(): GroupChatMember;

  getRole(): string;
  setRole(value: string): GroupChatMember;

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

export namespace GroupChatMember {
  export type AsObject = {
    user?: ChatUserInfo.AsObject,
    joined?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    left?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    role: string,
  }
}

export class AdminGroupChat extends jspb.Message {
  getGroupChatId(): number;
  setGroupChatId(value: number): AdminGroupChat;

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

  getIsDm(): boolean;
  setIsDm(value: boolean): AdminGroupChat;

  getCreator(): ChatUserInfo | undefined;
  setCreator(value?: ChatUserInfo): AdminGroupChat;
  hasCreator(): boolean;
  clearCreator(): AdminGroupChat;

  getMembersList(): Array<GroupChatMember>;
  setMembersList(value: Array<GroupChatMember>): AdminGroupChat;
  clearMembersList(): AdminGroupChat;
  addMembers(value?: GroupChatMember, index?: number): GroupChatMember;

  getMessagesList(): Array<ChatMessage>;
  setMessagesList(value: Array<ChatMessage>): AdminGroupChat;
  clearMessagesList(): AdminGroupChat;
  addMessages(value?: ChatMessage, index?: number): ChatMessage;

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

export namespace AdminGroupChat {
  export type AsObject = {
    groupChatId: number,
    title: string,
    isDm: boolean,
    creator?: ChatUserInfo.AsObject,
    membersList: Array<GroupChatMember.AsObject>,
    messagesList: Array<ChatMessage.AsObject>,
  }
}

export class AdminHostRequest extends jspb.Message {
  getHostRequestId(): number;
  setHostRequestId(value: number): AdminHostRequest;

  getSurfer(): ChatUserInfo | undefined;
  setSurfer(value?: ChatUserInfo): AdminHostRequest;
  hasSurfer(): boolean;
  clearSurfer(): AdminHostRequest;

  getHost(): ChatUserInfo | undefined;
  setHost(value?: ChatUserInfo): AdminHostRequest;
  hasHost(): boolean;
  clearHost(): AdminHostRequest;

  getStatus(): string;
  setStatus(value: string): AdminHostRequest;

  getFromDate(): string;
  setFromDate(value: string): AdminHostRequest;

  getToDate(): string;
  setToDate(value: string): AdminHostRequest;

  getCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreated(value?: google_protobuf_timestamp_pb.Timestamp): AdminHostRequest;
  hasCreated(): boolean;
  clearCreated(): AdminHostRequest;

  getMessagesList(): Array<ChatMessage>;
  setMessagesList(value: Array<ChatMessage>): AdminHostRequest;
  clearMessagesList(): AdminHostRequest;
  addMessages(value?: ChatMessage, index?: number): ChatMessage;

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

export namespace AdminHostRequest {
  export type AsObject = {
    hostRequestId: number,
    surfer?: ChatUserInfo.AsObject,
    host?: ChatUserInfo.AsObject,
    status: string,
    fromDate: string,
    toDate: string,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    messagesList: Array<ChatMessage.AsObject>,
  }
}

export class GetChatsRes extends jspb.Message {
  getUser(): ChatUserInfo | undefined;
  setUser(value?: ChatUserInfo): GetChatsRes;
  hasUser(): boolean;
  clearUser(): GetChatsRes;

  getHostRequestsList(): Array<AdminHostRequest>;
  setHostRequestsList(value: Array<AdminHostRequest>): GetChatsRes;
  clearHostRequestsList(): GetChatsRes;
  addHostRequests(value?: AdminHostRequest, index?: number): AdminHostRequest;

  getGroupChatsList(): Array<AdminGroupChat>;
  setGroupChatsList(value: Array<AdminGroupChat>): GetChatsRes;
  clearGroupChatsList(): GetChatsRes;
  addGroupChats(value?: AdminGroupChat, index?: number): AdminGroupChat;

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

export namespace GetChatsRes {
  export type AsObject = {
    user?: ChatUserInfo.AsObject,
    hostRequestsList: Array<AdminHostRequest.AsObject>,
    groupChatsList: Array<AdminGroupChat.AsObject>,
  }
}

export class DeleteEventReq extends jspb.Message {
  getEventId(): number;
  setEventId(value: number): DeleteEventReq;

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

export namespace DeleteEventReq {
  export type AsObject = {
    eventId: number,
  }
}

export class ListUserIdsReq extends jspb.Message {
  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): ListUserIdsReq;
  hasStartTime(): boolean;
  clearStartTime(): ListUserIdsReq;

  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): ListUserIdsReq;
  hasEndTime(): boolean;
  clearEndTime(): ListUserIdsReq;

  getPageSize(): number;
  setPageSize(value: number): ListUserIdsReq;

  getPageToken(): string;
  setPageToken(value: string): ListUserIdsReq;

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

export namespace ListUserIdsReq {
  export type AsObject = {
    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    pageSize: number,
    pageToken: string,
  }
}

export class ListUserIdsRes extends jspb.Message {
  getUserIdsList(): Array<number>;
  setUserIdsList(value: Array<number>): ListUserIdsRes;
  clearUserIdsList(): ListUserIdsRes;
  addUserIds(value: number, index?: number): ListUserIdsRes;

  getNextPageToken(): string;
  setNextPageToken(value: string): ListUserIdsRes;

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

export namespace ListUserIdsRes {
  export type AsObject = {
    userIdsList: Array<number>,
    nextPageToken: string,
  }
}

export class EditReferenceTextReq extends jspb.Message {
  getReferenceId(): number;
  setReferenceId(value: number): EditReferenceTextReq;

  getNewText(): string;
  setNewText(value: string): EditReferenceTextReq;

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

export namespace EditReferenceTextReq {
  export type AsObject = {
    referenceId: number,
    newText: string,
  }
}

export class DeleteReferenceReq extends jspb.Message {
  getReferenceId(): number;
  setReferenceId(value: number): DeleteReferenceReq;

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

export namespace DeleteReferenceReq {
  export type AsObject = {
    referenceId: number,
  }
}

export class GetUserReferencesReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetUserReferencesReq;

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

export namespace GetUserReferencesReq {
  export type AsObject = {
    user: string,
  }
}

export class AdminReference extends jspb.Message {
  getReferenceId(): number;
  setReferenceId(value: number): AdminReference;

  getFromUserId(): number;
  setFromUserId(value: number): AdminReference;

  getToUserId(): number;
  setToUserId(value: number): AdminReference;

  getReferenceType(): string;
  setReferenceType(value: string): AdminReference;

  getText(): string;
  setText(value: string): AdminReference;

  getPrivateText(): string;
  setPrivateText(value: string): AdminReference;

  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): AdminReference;
  hasTime(): boolean;
  clearTime(): AdminReference;

  getHostRequestId(): number;
  setHostRequestId(value: number): AdminReference;

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

  getWasAppropriate(): boolean;
  setWasAppropriate(value: boolean): AdminReference;

  getFromUser(): ChatUserInfo | undefined;
  setFromUser(value?: ChatUserInfo): AdminReference;
  hasFromUser(): boolean;
  clearFromUser(): AdminReference;

  getToUser(): ChatUserInfo | undefined;
  setToUser(value?: ChatUserInfo): AdminReference;
  hasToUser(): boolean;
  clearToUser(): AdminReference;

  getModerationVisibility(): string;
  setModerationVisibility(value: string): AdminReference;

  getHostingCity(): string;
  setHostingCity(value: string): AdminReference;

  getFromDate(): string;
  setFromDate(value: string): AdminReference;

  getToDate(): string;
  setToDate(value: string): AdminReference;

  getStatus(): string;
  setStatus(value: string): AdminReference;

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

export namespace AdminReference {
  export type AsObject = {
    referenceId: number,
    fromUserId: number,
    toUserId: number,
    referenceType: string,
    text: string,
    privateText: string,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    hostRequestId: number,
    rating: number,
    wasAppropriate: boolean,
    fromUser?: ChatUserInfo.AsObject,
    toUser?: ChatUserInfo.AsObject,
    moderationVisibility: string,
    hostingCity: string,
    fromDate: string,
    toDate: string,
    status: string,
  }
}

export class GetUserReferencesRes extends jspb.Message {
  getReferencesFromList(): Array<AdminReference>;
  setReferencesFromList(value: Array<AdminReference>): GetUserReferencesRes;
  clearReferencesFromList(): GetUserReferencesRes;
  addReferencesFrom(value?: AdminReference, index?: number): AdminReference;

  getReferencesToList(): Array<AdminReference>;
  setReferencesToList(value: Array<AdminReference>): GetUserReferencesRes;
  clearReferencesToList(): GetUserReferencesRes;
  addReferencesTo(value?: AdminReference, index?: number): AdminReference;

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

export namespace GetUserReferencesRes {
  export type AsObject = {
    referencesFromList: Array<AdminReference.AsObject>,
    referencesToList: Array<AdminReference.AsObject>,
  }
}

export class GetFriendRequestsReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetFriendRequestsReq;

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

export namespace GetFriendRequestsReq {
  export type AsObject = {
    user: string,
  }
}

export class AdminFriendRequest extends jspb.Message {
  getFriendRequestId(): number;
  setFriendRequestId(value: number): AdminFriendRequest;

  getFromUser(): ChatUserInfo | undefined;
  setFromUser(value?: ChatUserInfo): AdminFriendRequest;
  hasFromUser(): boolean;
  clearFromUser(): AdminFriendRequest;

  getToUser(): ChatUserInfo | undefined;
  setToUser(value?: ChatUserInfo): AdminFriendRequest;
  hasToUser(): boolean;
  clearToUser(): AdminFriendRequest;

  getStatus(): string;
  setStatus(value: string): AdminFriendRequest;

  getTimeSent(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTimeSent(value?: google_protobuf_timestamp_pb.Timestamp): AdminFriendRequest;
  hasTimeSent(): boolean;
  clearTimeSent(): AdminFriendRequest;

  getTimeResponded(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTimeResponded(value?: google_protobuf_timestamp_pb.Timestamp): AdminFriendRequest;
  hasTimeResponded(): boolean;
  clearTimeResponded(): AdminFriendRequest;

  getModerationVisibility(): string;
  setModerationVisibility(value: string): AdminFriendRequest;

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

export namespace AdminFriendRequest {
  export type AsObject = {
    friendRequestId: number,
    fromUser?: ChatUserInfo.AsObject,
    toUser?: ChatUserInfo.AsObject,
    status: string,
    timeSent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    timeResponded?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    moderationVisibility: string,
  }
}

export class GetFriendRequestsRes extends jspb.Message {
  getSentList(): Array<AdminFriendRequest>;
  setSentList(value: Array<AdminFriendRequest>): GetFriendRequestsRes;
  clearSentList(): GetFriendRequestsRes;
  addSent(value?: AdminFriendRequest, index?: number): AdminFriendRequest;

  getReceivedList(): Array<AdminFriendRequest>;
  setReceivedList(value: Array<AdminFriendRequest>): GetFriendRequestsRes;
  clearReceivedList(): GetFriendRequestsRes;
  addReceived(value?: AdminFriendRequest, index?: number): AdminFriendRequest;

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

export namespace GetFriendRequestsRes {
  export type AsObject = {
    sentList: Array<AdminFriendRequest.AsObject>,
    receivedList: Array<AdminFriendRequest.AsObject>,
  }
}

export class GetUserBlocksReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetUserBlocksReq;

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

export namespace GetUserBlocksReq {
  export type AsObject = {
    user: string,
  }
}

export class AdminUserBlock extends jspb.Message {
  getUser(): ChatUserInfo | undefined;
  setUser(value?: ChatUserInfo): AdminUserBlock;
  hasUser(): boolean;
  clearUser(): AdminUserBlock;

  getTimeBlocked(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTimeBlocked(value?: google_protobuf_timestamp_pb.Timestamp): AdminUserBlock;
  hasTimeBlocked(): boolean;
  clearTimeBlocked(): AdminUserBlock;

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

export namespace AdminUserBlock {
  export type AsObject = {
    user?: ChatUserInfo.AsObject,
    timeBlocked?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class GetUserBlocksRes extends jspb.Message {
  getBlockedUsersList(): Array<AdminUserBlock>;
  setBlockedUsersList(value: Array<AdminUserBlock>): GetUserBlocksRes;
  clearBlockedUsersList(): GetUserBlocksRes;
  addBlockedUsers(value?: AdminUserBlock, index?: number): AdminUserBlock;

  getBlockingUsersList(): Array<AdminUserBlock>;
  setBlockingUsersList(value: Array<AdminUserBlock>): GetUserBlocksRes;
  clearBlockingUsersList(): GetUserBlocksRes;
  addBlockingUsers(value?: AdminUserBlock, index?: number): AdminUserBlock;

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

export namespace GetUserBlocksRes {
  export type AsObject = {
    blockedUsersList: Array<AdminUserBlock.AsObject>,
    blockingUsersList: Array<AdminUserBlock.AsObject>,
  }
}

export class GetNonvisibleUserAccessLogReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): GetNonvisibleUserAccessLogReq;

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

export namespace GetNonvisibleUserAccessLogReq {
  export type AsObject = {
    user: string,
  }
}

export class NonvisibleUserAccessLogEntry extends jspb.Message {
  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): NonvisibleUserAccessLogEntry;
  hasTime(): boolean;
  clearTime(): NonvisibleUserAccessLogEntry;

  getAccessType(): NonvisibleUserAccessType;
  setAccessType(value: NonvisibleUserAccessType): NonvisibleUserAccessLogEntry;

  getTargetState(): NonvisibleUserState;
  setTargetState(value: NonvisibleUserState): NonvisibleUserAccessLogEntry;

  getTargetUserId(): number;
  setTargetUserId(value: number): NonvisibleUserAccessLogEntry;

  getActorUserId(): google_protobuf_wrappers_pb.Int64Value | undefined;
  setActorUserId(value?: google_protobuf_wrappers_pb.Int64Value): NonvisibleUserAccessLogEntry;
  hasActorUserId(): boolean;
  clearActorUserId(): NonvisibleUserAccessLogEntry;

  getActorUsername(): string;
  setActorUsername(value: string): NonvisibleUserAccessLogEntry;

  getIpAddress(): string;
  setIpAddress(value: string): NonvisibleUserAccessLogEntry;

  getUserAgent(): string;
  setUserAgent(value: string): NonvisibleUserAccessLogEntry;

  getSofa(): string;
  setSofa(value: string): NonvisibleUserAccessLogEntry;

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

export namespace NonvisibleUserAccessLogEntry {
  export type AsObject = {
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    accessType: NonvisibleUserAccessType,
    targetState: NonvisibleUserState,
    targetUserId: number,
    actorUserId?: google_protobuf_wrappers_pb.Int64Value.AsObject,
    actorUsername: string,
    ipAddress: string,
    userAgent: string,
    sofa: string,
  }
}

export class GetNonvisibleUserAccessLogRes extends jspb.Message {
  getEntriesList(): Array<NonvisibleUserAccessLogEntry>;
  setEntriesList(value: Array<NonvisibleUserAccessLogEntry>): GetNonvisibleUserAccessLogRes;
  clearEntriesList(): GetNonvisibleUserAccessLogRes;
  addEntries(value?: NonvisibleUserAccessLogEntry, index?: number): NonvisibleUserAccessLogEntry;

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

export namespace GetNonvisibleUserAccessLogRes {
  export type AsObject = {
    entriesList: Array<NonvisibleUserAccessLogEntry.AsObject>,
  }
}

export class EditDiscussionReq extends jspb.Message {
  getDiscussionId(): number;
  setDiscussionId(value: number): EditDiscussionReq;

  getNewTitle(): string;
  setNewTitle(value: string): EditDiscussionReq;

  getNewContent(): string;
  setNewContent(value: string): EditDiscussionReq;

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

export namespace EditDiscussionReq {
  export type AsObject = {
    discussionId: number,
    newTitle: string,
    newContent: string,
  }
}

export class AdminDeleteDiscussionReq extends jspb.Message {
  getDiscussionId(): number;
  setDiscussionId(value: number): AdminDeleteDiscussionReq;

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

export namespace AdminDeleteDiscussionReq {
  export type AsObject = {
    discussionId: number,
  }
}

export class EditReplyReq extends jspb.Message {
  getReplyId(): number;
  setReplyId(value: number): EditReplyReq;

  getNewContent(): string;
  setNewContent(value: string): EditReplyReq;

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

export namespace EditReplyReq {
  export type AsObject = {
    replyId: number,
    newContent: string,
  }
}

export class AddUsersToModerationUserListReq extends jspb.Message {
  getUsersList(): Array<string>;
  setUsersList(value: Array<string>): AddUsersToModerationUserListReq;
  clearUsersList(): AddUsersToModerationUserListReq;
  addUsers(value: string, index?: number): AddUsersToModerationUserListReq;

  getModerationListId(): number;
  setModerationListId(value: number): AddUsersToModerationUserListReq;

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

export namespace AddUsersToModerationUserListReq {
  export type AsObject = {
    usersList: Array<string>,
    moderationListId: number,
  }
}

export class ListModerationUserListsReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): ListModerationUserListsReq;

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

export namespace ListModerationUserListsReq {
  export type AsObject = {
    user: string,
  }
}

export class ModerationList extends jspb.Message {
  getModerationListId(): number;
  setModerationListId(value: number): ModerationList;

  getMembersList(): Array<UserDetails>;
  setMembersList(value: Array<UserDetails>): ModerationList;
  clearMembersList(): ModerationList;
  addMembers(value?: UserDetails, index?: number): UserDetails;

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

export namespace ModerationList {
  export type AsObject = {
    moderationListId: number,
    membersList: Array<UserDetails.AsObject>,
  }
}

export class ListModerationUserListsRes extends jspb.Message {
  getModerationListsList(): Array<ModerationList>;
  setModerationListsList(value: Array<ModerationList>): ListModerationUserListsRes;
  clearModerationListsList(): ListModerationUserListsRes;
  addModerationLists(value?: ModerationList, index?: number): ModerationList;

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

export namespace ListModerationUserListsRes {
  export type AsObject = {
    moderationListsList: Array<ModerationList.AsObject>,
  }
}

export class AddUsersToModerationUserListRes extends jspb.Message {
  getModerationListId(): number;
  setModerationListId(value: number): AddUsersToModerationUserListRes;

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

export namespace AddUsersToModerationUserListRes {
  export type AsObject = {
    moderationListId: number,
  }
}

export class RemoveUserFromModerationUserListReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): RemoveUserFromModerationUserListReq;

  getModerationListId(): number;
  setModerationListId(value: number): RemoveUserFromModerationUserListReq;

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

export namespace RemoveUserFromModerationUserListReq {
  export type AsObject = {
    user: string,
    moderationListId: number,
  }
}

export class CreateAccountDeletionLinkReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): CreateAccountDeletionLinkReq;

  getExpiryDays(): number;
  setExpiryDays(value: number): CreateAccountDeletionLinkReq;

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

export namespace CreateAccountDeletionLinkReq {
  export type AsObject = {
    user: string,
    expiryDays: number,
  }
}

export class CreateAccountDeletionLinkRes extends jspb.Message {
  getAccountDeletionConfirmUrl(): string;
  setAccountDeletionConfirmUrl(value: string): CreateAccountDeletionLinkRes;

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

export namespace CreateAccountDeletionLinkRes {
  export type AsObject = {
    accountDeletionConfirmUrl: string,
  }
}

export class AccessStatsReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): AccessStatsReq;

  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): AccessStatsReq;
  hasStartTime(): boolean;
  clearStartTime(): AccessStatsReq;

  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): AccessStatsReq;
  hasEndTime(): boolean;
  clearEndTime(): AccessStatsReq;

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

export namespace AccessStatsReq {
  export type AsObject = {
    user: string,
    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class AccessStat extends jspb.Message {
  getIpAddress(): string;
  setIpAddress(value: string): AccessStat;

  getAsn(): string;
  setAsn(value: string): AccessStat;

  getAsorg(): string;
  setAsorg(value: string): AccessStat;

  getAsnetwork(): string;
  setAsnetwork(value: string): AccessStat;

  getUserAgent(): string;
  setUserAgent(value: string): AccessStat;

  getOperatingSystem(): string;
  setOperatingSystem(value: string): AccessStat;

  getBrowser(): string;
  setBrowser(value: string): AccessStat;

  getDevice(): string;
  setDevice(value: string): AccessStat;

  getApproximateLocation(): string;
  setApproximateLocation(value: string): AccessStat;

  getApiCallCount(): number;
  setApiCallCount(value: number): AccessStat;

  getPeriodsCount(): number;
  setPeriodsCount(value: number): AccessStat;

  getFirstSeen(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setFirstSeen(value?: google_protobuf_timestamp_pb.Timestamp): AccessStat;
  hasFirstSeen(): boolean;
  clearFirstSeen(): AccessStat;

  getLastSeen(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setLastSeen(value?: google_protobuf_timestamp_pb.Timestamp): AccessStat;
  hasLastSeen(): boolean;
  clearLastSeen(): AccessStat;

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

export namespace AccessStat {
  export type AsObject = {
    ipAddress: string,
    asn: string,
    asorg: string,
    asnetwork: string,
    userAgent: string,
    operatingSystem: string,
    browser: string,
    device: string,
    approximateLocation: string,
    apiCallCount: number,
    periodsCount: number,
    firstSeen?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    lastSeen?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class AccessStatsRes extends jspb.Message {
  getStatsList(): Array<AccessStat>;
  setStatsList(value: Array<AccessStat>): AccessStatsRes;
  clearStatsList(): AccessStatsRes;
  addStats(value?: AccessStat, index?: number): AccessStat;

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

export namespace AccessStatsRes {
  export type AsObject = {
    statsList: Array<AccessStat.AsObject>,
  }
}

export class SetLastDonatedReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): SetLastDonatedReq;

  getLastDonated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setLastDonated(value?: google_protobuf_timestamp_pb.Timestamp): SetLastDonatedReq;
  hasLastDonated(): boolean;
  clearLastDonated(): SetLastDonatedReq;

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

export namespace SetLastDonatedReq {
  export type AsObject = {
    user: string,
    lastDonated?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class CreateAdminTagReq extends jspb.Message {
  getTag(): string;
  setTag(value: string): CreateAdminTagReq;

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

export namespace CreateAdminTagReq {
  export type AsObject = {
    tag: string,
  }
}

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

export namespace ListAdminTagsReq {
  export type AsObject = {
  }
}

export class ListAdminTagsRes extends jspb.Message {
  getTagsList(): Array<AdminTagInfo>;
  setTagsList(value: Array<AdminTagInfo>): ListAdminTagsRes;
  clearTagsList(): ListAdminTagsRes;
  addTags(value?: AdminTagInfo, index?: number): AdminTagInfo;

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

export namespace ListAdminTagsRes {
  export type AsObject = {
    tagsList: Array<AdminTagInfo.AsObject>,
  }
}

export class AddAdminTagToUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): AddAdminTagToUserReq;

  getTag(): string;
  setTag(value: string): AddAdminTagToUserReq;

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

export namespace AddAdminTagToUserReq {
  export type AsObject = {
    user: string,
    tag: string,
  }
}

export class RemoveAdminTagFromUserReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): RemoveAdminTagFromUserReq;

  getTag(): string;
  setTag(value: string): RemoveAdminTagFromUserReq;

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

export namespace RemoveAdminTagFromUserReq {
  export type AsObject = {
    user: string,
    tag: string,
  }
}

export class SetModScoreReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): SetModScoreReq;

  getModScore(): number;
  setModScore(value: number): SetModScoreReq;

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

export namespace SetModScoreReq {
  export type AsObject = {
    user: string,
    modScore: number,
  }
}

export class ListAdminActionsReq extends jspb.Message {
  getAdminUserId(): number;
  setAdminUserId(value: number): ListAdminActionsReq;

  getTargetUserId(): number;
  setTargetUserId(value: number): ListAdminActionsReq;

  getPageSize(): number;
  setPageSize(value: number): ListAdminActionsReq;

  getPageToken(): string;
  setPageToken(value: string): ListAdminActionsReq;

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

export namespace ListAdminActionsReq {
  export type AsObject = {
    adminUserId: number,
    targetUserId: number,
    pageSize: number,
    pageToken: string,
  }
}

export class ListAdminActionsRes extends jspb.Message {
  getAdminActionsList(): Array<AdminActionLog>;
  setAdminActionsList(value: Array<AdminActionLog>): ListAdminActionsRes;
  clearAdminActionsList(): ListAdminActionsRes;
  addAdminActions(value?: AdminActionLog, index?: number): AdminActionLog;

  getNextPageToken(): string;
  setNextPageToken(value: string): ListAdminActionsRes;

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

export namespace ListAdminActionsRes {
  export type AsObject = {
    adminActionsList: Array<AdminActionLog.AsObject>,
    nextPageToken: string,
  }
}

export class ListUserUploadsReq extends jspb.Message {
  getUser(): string;
  setUser(value: string): ListUserUploadsReq;

  getPageSize(): number;
  setPageSize(value: number): ListUserUploadsReq;

  getPageToken(): string;
  setPageToken(value: string): ListUserUploadsReq;

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

export namespace ListUserUploadsReq {
  export type AsObject = {
    user: string,
    pageSize: number,
    pageToken: string,
  }
}

export class UploadUse extends jspb.Message {
  getType(): UploadUseType;
  setType(value: UploadUseType): UploadUse;

  getIsCurrent(): boolean;
  setIsCurrent(value: boolean): UploadUse;

  getUserId(): number;
  setUserId(value: number): UploadUse;

  getEventId(): number;
  setEventId(value: number): UploadUse;

  getPageId(): number;
  setPageId(value: number): UploadUse;

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

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

export namespace UploadUse {
  export type AsObject = {
    type: UploadUseType,
    isCurrent: boolean,
    userId: number,
    eventId: number,
    pageId: number,
    url: string,
  }
}

export class UserUpload extends jspb.Message {
  getKey(): string;
  setKey(value: string): UserUpload;

  getFilename(): string;
  setFilename(value: string): UserUpload;

  getFullUrl(): string;
  setFullUrl(value: string): UserUpload;

  getThumbnailUrl(): string;
  setThumbnailUrl(value: string): UserUpload;

  getCredit(): string;
  setCredit(value: string): UserUpload;

  getCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreated(value?: google_protobuf_timestamp_pb.Timestamp): UserUpload;
  hasCreated(): boolean;
  clearCreated(): UserUpload;

  getUsesList(): Array<UploadUse>;
  setUsesList(value: Array<UploadUse>): UserUpload;
  clearUsesList(): UserUpload;
  addUses(value?: UploadUse, index?: number): UploadUse;

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

export namespace UserUpload {
  export type AsObject = {
    key: string,
    filename: string,
    fullUrl: string,
    thumbnailUrl: string,
    credit: string,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    usesList: Array<UploadUse.AsObject>,
  }
}

export class ListUserUploadsRes extends jspb.Message {
  getUploadsList(): Array<UserUpload>;
  setUploadsList(value: Array<UserUpload>): ListUserUploadsRes;
  clearUploadsList(): ListUserUploadsRes;
  addUploads(value?: UserUpload, index?: number): UserUpload;

  getNextPageToken(): string;
  setNextPageToken(value: string): ListUserUploadsRes;

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

export namespace ListUserUploadsRes {
  export type AsObject = {
    uploadsList: Array<UserUpload.AsObject>,
    nextPageToken: string,
  }
}

export class OTAPackage extends jspb.Message {
  getOtaPackageId(): number;
  setOtaPackageId(value: number): OTAPackage;

  getCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreated(value?: google_protobuf_timestamp_pb.Timestamp): OTAPackage;
  hasCreated(): boolean;
  clearCreated(): OTAPackage;

  getCreatorUserId(): number;
  setCreatorUserId(value: number): OTAPackage;

  getPlatform(): OTAPlatform;
  setPlatform(value: OTAPlatform): OTAPackage;

  getFingerprint(): string;
  setFingerprint(value: string): OTAPackage;

  getVersion(): string;
  setVersion(value: string): OTAPackage;

  getManifestCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setManifestCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): OTAPackage;
  hasManifestCreatedAt(): boolean;
  clearManifestCreatedAt(): OTAPackage;

  getManifestId(): string;
  setManifestId(value: string): OTAPackage;

  getBanned(): boolean;
  setBanned(value: boolean): OTAPackage;

  getBannedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setBannedAt(value?: google_protobuf_timestamp_pb.Timestamp): OTAPackage;
  hasBannedAt(): boolean;
  clearBannedAt(): OTAPackage;

  getBannedByUserId(): number;
  setBannedByUserId(value: number): OTAPackage;

  getBannedReason(): string;
  setBannedReason(value: string): OTAPackage;

  getLive(): boolean;
  setLive(value: boolean): OTAPackage;

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

export namespace OTAPackage {
  export type AsObject = {
    otaPackageId: number,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    creatorUserId: number,
    platform: OTAPlatform,
    fingerprint: string,
    version: string,
    manifestCreatedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    manifestId: string,
    banned: boolean,
    bannedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    bannedByUserId: number,
    bannedReason: string,
    live: boolean,
  }
}

export class CreateOTAPackageReq extends jspb.Message {
  getPlatform(): OTAPlatform;
  setPlatform(value: OTAPlatform): CreateOTAPackageReq;

  getVersion(): string;
  setVersion(value: string): CreateOTAPackageReq;

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

export namespace CreateOTAPackageReq {
  export type AsObject = {
    platform: OTAPlatform,
    version: string,
  }
}

export class ListOTAPackagesReq extends jspb.Message {
  getPlatform(): OTAPlatform;
  setPlatform(value: OTAPlatform): ListOTAPackagesReq;

  getFingerprint(): string;
  setFingerprint(value: string): ListOTAPackagesReq;

  getIncludeBanned(): boolean;
  setIncludeBanned(value: boolean): ListOTAPackagesReq;

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

export namespace ListOTAPackagesReq {
  export type AsObject = {
    platform: OTAPlatform,
    fingerprint: string,
    includeBanned: boolean,
  }
}

export class ListOTAPackagesRes extends jspb.Message {
  getPackagesList(): Array<OTAPackage>;
  setPackagesList(value: Array<OTAPackage>): ListOTAPackagesRes;
  clearPackagesList(): ListOTAPackagesRes;
  addPackages(value?: OTAPackage, index?: number): OTAPackage;

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

export namespace ListOTAPackagesRes {
  export type AsObject = {
    packagesList: Array<OTAPackage.AsObject>,
  }
}

export class BanOTAPackageReq extends jspb.Message {
  getOtaPackageId(): number;
  setOtaPackageId(value: number): BanOTAPackageReq;

  getReason(): string;
  setReason(value: string): BanOTAPackageReq;

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

export namespace BanOTAPackageReq {
  export type AsObject = {
    otaPackageId: number,
    reason: string,
  }
}

export enum AdminActionLevel { 
  ADMIN_ACTION_LEVEL_UNSPECIFIED = 0,
  ADMIN_ACTION_LEVEL_TRACE = 4,
  ADMIN_ACTION_LEVEL_DEBUG = 1,
  ADMIN_ACTION_LEVEL_NORMAL = 2,
  ADMIN_ACTION_LEVEL_HIGH = 3,
}
export enum NonvisibleUserAccessType { 
  NONVISIBLE_USER_ACCESS_TYPE_UNSPECIFIED = 0,
  NONVISIBLE_USER_ACCESS_TYPE_LOGIN_ATTEMPT = 1,
  NONVISIBLE_USER_ACCESS_TYPE_PROFILE_VIEW = 2,
  NONVISIBLE_USER_ACCESS_TYPE_GHOST_SERVED = 3,
}
export enum NonvisibleUserState { 
  NONVISIBLE_USER_STATE_UNSPECIFIED = 0,
  NONVISIBLE_USER_STATE_BANNED = 1,
  NONVISIBLE_USER_STATE_SHADOWED = 2,
  NONVISIBLE_USER_STATE_DELETED = 3,
}
export enum UploadUseType { 
  UPLOAD_USE_TYPE_UNSPECIFIED = 0,
  UPLOAD_USE_TYPE_PROFILE_GALLERY_PHOTO = 1,
  UPLOAD_USE_TYPE_PROFILE_GALLERY_PHOTO_AVATAR = 2,
  UPLOAD_USE_TYPE_EVENT = 3,
  UPLOAD_USE_TYPE_PAGE = 4,
}
export enum OTAPlatform { 
  OTA_PLATFORM_UNSPECIFIED = 0,
  OTA_PLATFORM_IOS = 1,
  OTA_PLATFORM_ANDROID = 2,
}
