import * as jspb from 'google-protobuf'

import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb'; // proto import: "google/protobuf/timestamp.proto"
import * as admin_pb from './admin_pb'; // proto import: "admin.proto"
import * as annotations_pb from './annotations_pb'; // proto import: "annotations.proto"


export class ModerationStateInfo extends jspb.Message {
  getModerationStateId(): number;
  setModerationStateId(value: number): ModerationStateInfo;

  getObjectType(): ModerationObjectType;
  setObjectType(value: ModerationObjectType): ModerationStateInfo;

  getObjectId(): number;
  setObjectId(value: number): ModerationStateInfo;

  getVisibility(): ModerationVisibility;
  setVisibility(value: ModerationVisibility): ModerationStateInfo;

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

  getUpdated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setUpdated(value?: google_protobuf_timestamp_pb.Timestamp): ModerationStateInfo;
  hasUpdated(): boolean;
  clearUpdated(): ModerationStateInfo;

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

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

  getAuthor(): admin_pb.UserDetails | undefined;
  setAuthor(value?: admin_pb.UserDetails): ModerationStateInfo;
  hasAuthor(): boolean;
  clearAuthor(): ModerationStateInfo;

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

export namespace ModerationStateInfo {
  export type AsObject = {
    moderationStateId: number,
    objectType: ModerationObjectType,
    objectId: number,
    visibility: ModerationVisibility,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    updated?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    authorUserId: number,
    content: string,
    author?: admin_pb.UserDetails.AsObject,
  }
}

export class ModerationQueueItemInfo extends jspb.Message {
  getQueueItemId(): number;
  setQueueItemId(value: number): ModerationQueueItemInfo;

  getModerationStateId(): number;
  setModerationStateId(value: number): ModerationQueueItemInfo;

  getTimeCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTimeCreated(value?: google_protobuf_timestamp_pb.Timestamp): ModerationQueueItemInfo;
  hasTimeCreated(): boolean;
  clearTimeCreated(): ModerationQueueItemInfo;

  getTrigger(): ModerationTrigger;
  setTrigger(value: ModerationTrigger): ModerationQueueItemInfo;

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

  getIsResolved(): boolean;
  setIsResolved(value: boolean): ModerationQueueItemInfo;

  getResolvedByLogId(): number;
  setResolvedByLogId(value: number): ModerationQueueItemInfo;

  getModerationState(): ModerationStateInfo | undefined;
  setModerationState(value?: ModerationStateInfo): ModerationQueueItemInfo;
  hasModerationState(): boolean;
  clearModerationState(): ModerationQueueItemInfo;

  getPriority(): number;
  setPriority(value: number): ModerationQueueItemInfo;

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

export namespace ModerationQueueItemInfo {
  export type AsObject = {
    queueItemId: number,
    moderationStateId: number,
    timeCreated?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    trigger: ModerationTrigger,
    reason: string,
    isResolved: boolean,
    resolvedByLogId: number,
    moderationState?: ModerationStateInfo.AsObject,
    priority: number,
  }
}

export class ModerationLogEntryInfo extends jspb.Message {
  getLogEntryId(): number;
  setLogEntryId(value: number): ModerationLogEntryInfo;

  getModerationStateId(): number;
  setModerationStateId(value: number): ModerationLogEntryInfo;

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

  getAction(): ModerationAction;
  setAction(value: ModerationAction): ModerationLogEntryInfo;

  getModeratorUserId(): number;
  setModeratorUserId(value: number): ModerationLogEntryInfo;

  getNewVisibility(): ModerationVisibility;
  setNewVisibility(value: ModerationVisibility): ModerationLogEntryInfo;

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

  getNewPriority(): number;
  setNewPriority(value: number): ModerationLogEntryInfo;

  getQueueItemId(): number;
  setQueueItemId(value: number): ModerationLogEntryInfo;

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

export namespace ModerationLogEntryInfo {
  export type AsObject = {
    logEntryId: number,
    moderationStateId: number,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    action: ModerationAction,
    moderatorUserId: number,
    newVisibility: ModerationVisibility,
    reason: string,
    newPriority: number,
    queueItemId: number,
  }
}

export class GetModerationQueueReq extends jspb.Message {
  getTriggersList(): Array<ModerationTrigger>;
  setTriggersList(value: Array<ModerationTrigger>): GetModerationQueueReq;
  clearTriggersList(): GetModerationQueueReq;
  addTriggers(value: ModerationTrigger, index?: number): GetModerationQueueReq;

  getObjectType(): ModerationObjectType;
  setObjectType(value: ModerationObjectType): GetModerationQueueReq;

  getUnresolvedOnly(): boolean;
  setUnresolvedOnly(value: boolean): GetModerationQueueReq;

  getCreatedBefore(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreatedBefore(value?: google_protobuf_timestamp_pb.Timestamp): GetModerationQueueReq;
  hasCreatedBefore(): boolean;
  clearCreatedBefore(): GetModerationQueueReq;

  getCreatedAfter(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreatedAfter(value?: google_protobuf_timestamp_pb.Timestamp): GetModerationQueueReq;
  hasCreatedAfter(): boolean;
  clearCreatedAfter(): GetModerationQueueReq;

  getItemAuthorUserId(): number;
  setItemAuthorUserId(value: number): GetModerationQueueReq;

  getPriorityMin(): number;
  setPriorityMin(value: number): GetModerationQueueReq;
  hasPriorityMin(): boolean;
  clearPriorityMin(): GetModerationQueueReq;

  getPriorityMax(): number;
  setPriorityMax(value: number): GetModerationQueueReq;
  hasPriorityMax(): boolean;
  clearPriorityMax(): GetModerationQueueReq;

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

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

  getNewestFirst(): boolean;
  setNewestFirst(value: boolean): GetModerationQueueReq;

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

export namespace GetModerationQueueReq {
  export type AsObject = {
    triggersList: Array<ModerationTrigger>,
    objectType: ModerationObjectType,
    unresolvedOnly: boolean,
    createdBefore?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    createdAfter?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    itemAuthorUserId: number,
    priorityMin?: number,
    priorityMax?: number,
    pageSize: number,
    pageToken: string,
    newestFirst: boolean,
  }

  export enum PriorityMinCase { 
    _PRIORITY_MIN_NOT_SET = 0,
    PRIORITY_MIN = 10,
  }

  export enum PriorityMaxCase { 
    _PRIORITY_MAX_NOT_SET = 0,
    PRIORITY_MAX = 11,
  }
}

export class GetModerationQueueRes extends jspb.Message {
  getQueueItemsList(): Array<ModerationQueueItemInfo>;
  setQueueItemsList(value: Array<ModerationQueueItemInfo>): GetModerationQueueRes;
  clearQueueItemsList(): GetModerationQueueRes;
  addQueueItems(value?: ModerationQueueItemInfo, index?: number): ModerationQueueItemInfo;

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

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

export namespace GetModerationQueueRes {
  export type AsObject = {
    queueItemsList: Array<ModerationQueueItemInfo.AsObject>,
    nextPageToken: string,
  }
}

export class GetModerationStateReq extends jspb.Message {
  getObjectType(): ModerationObjectType;
  setObjectType(value: ModerationObjectType): GetModerationStateReq;

  getObjectId(): number;
  setObjectId(value: number): GetModerationStateReq;

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

export namespace GetModerationStateReq {
  export type AsObject = {
    objectType: ModerationObjectType,
    objectId: number,
  }
}

export class GetModerationStateRes extends jspb.Message {
  getModerationState(): ModerationStateInfo | undefined;
  setModerationState(value?: ModerationStateInfo): GetModerationStateRes;
  hasModerationState(): boolean;
  clearModerationState(): GetModerationStateRes;

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

export namespace GetModerationStateRes {
  export type AsObject = {
    moderationState?: ModerationStateInfo.AsObject,
  }
}

export class GetModerationLogReq extends jspb.Message {
  getModerationStateId(): number;
  setModerationStateId(value: number): GetModerationLogReq;

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

export namespace GetModerationLogReq {
  export type AsObject = {
    moderationStateId: number,
  }
}

export class GetModerationLogRes extends jspb.Message {
  getLogEntriesList(): Array<ModerationLogEntryInfo>;
  setLogEntriesList(value: Array<ModerationLogEntryInfo>): GetModerationLogRes;
  clearLogEntriesList(): GetModerationLogRes;
  addLogEntries(value?: ModerationLogEntryInfo, index?: number): ModerationLogEntryInfo;

  getModerationState(): ModerationStateInfo | undefined;
  setModerationState(value?: ModerationStateInfo): GetModerationLogRes;
  hasModerationState(): boolean;
  clearModerationState(): GetModerationLogRes;

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

export namespace GetModerationLogRes {
  export type AsObject = {
    logEntriesList: Array<ModerationLogEntryInfo.AsObject>,
    moderationState?: ModerationStateInfo.AsObject,
  }
}

export class ModerateContentReq extends jspb.Message {
  getModerationStateId(): number;
  setModerationStateId(value: number): ModerateContentReq;

  getAction(): ModerationAction;
  setAction(value: ModerationAction): ModerateContentReq;

  getVisibility(): ModerationVisibility;
  setVisibility(value: ModerationVisibility): ModerateContentReq;

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

  getPriority(): number;
  setPriority(value: number): ModerateContentReq;

  getQueueItemId(): number;
  setQueueItemId(value: number): ModerateContentReq;

  getTrigger(): ModerationTrigger;
  setTrigger(value: ModerationTrigger): ModerateContentReq;

  getSupersedeQueueItemId(): number;
  setSupersedeQueueItemId(value: number): ModerateContentReq;

  getClearFlags(): boolean;
  setClearFlags(value: boolean): ModerateContentReq;

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

export namespace ModerateContentReq {
  export type AsObject = {
    moderationStateId: number,
    action: ModerationAction,
    visibility: ModerationVisibility,
    reason: string,
    priority: number,
    queueItemId: number,
    trigger: ModerationTrigger,
    supersedeQueueItemId: number,
    clearFlags: boolean,
  }
}

export class ModerateContentRes extends jspb.Message {
  getModerationState(): ModerationStateInfo | undefined;
  setModerationState(value?: ModerationStateInfo): ModerateContentRes;
  hasModerationState(): boolean;
  clearModerationState(): ModerateContentRes;

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

export namespace ModerateContentRes {
  export type AsObject = {
    moderationState?: ModerationStateInfo.AsObject,
  }
}

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

  getVisibility(): ModerationVisibility;
  setVisibility(value: ModerationVisibility): SetUserContentVisibilityReq;

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

  getFromVisibilityList(): Array<ModerationVisibility>;
  setFromVisibilityList(value: Array<ModerationVisibility>): SetUserContentVisibilityReq;
  clearFromVisibilityList(): SetUserContentVisibilityReq;
  addFromVisibility(value: ModerationVisibility, index?: number): SetUserContentVisibilityReq;

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

export namespace SetUserContentVisibilityReq {
  export type AsObject = {
    userId: number,
    visibility: ModerationVisibility,
    reason: string,
    fromVisibilityList: Array<ModerationVisibility>,
  }
}

export class SetUserContentVisibilityRes extends jspb.Message {
  getUpdatedCount(): number;
  setUpdatedCount(value: number): SetUserContentVisibilityRes;

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

export namespace SetUserContentVisibilityRes {
  export type AsObject = {
    updatedCount: number,
  }
}

export class ListModerationStatesReq extends jspb.Message {
  getAuthorUserId(): number;
  setAuthorUserId(value: number): ListModerationStatesReq;

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

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

  getNewestFirst(): boolean;
  setNewestFirst(value: boolean): ListModerationStatesReq;

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

export namespace ListModerationStatesReq {
  export type AsObject = {
    authorUserId: number,
    pageSize: number,
    pageToken: string,
    newestFirst: boolean,
  }
}

export class ListModerationStatesRes extends jspb.Message {
  getModerationStatesList(): Array<ModerationStateInfo>;
  setModerationStatesList(value: Array<ModerationStateInfo>): ListModerationStatesRes;
  clearModerationStatesList(): ListModerationStatesRes;
  addModerationStates(value?: ModerationStateInfo, index?: number): ModerationStateInfo;

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

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

export namespace ListModerationStatesRes {
  export type AsObject = {
    moderationStatesList: Array<ModerationStateInfo.AsObject>,
    nextPageToken: string,
  }
}

export enum ModerationVisibility { 
  MODERATION_VISIBILITY_UNSPECIFIED = 0,
  MODERATION_VISIBILITY_HIDDEN = 1,
  MODERATION_VISIBILITY_SHADOWED = 2,
  MODERATION_VISIBILITY_VISIBLE = 3,
  MODERATION_VISIBILITY_UNLISTED = 4,
}
export enum ModerationTrigger { 
  MODERATION_TRIGGER_UNSPECIFIED = 0,
  MODERATION_TRIGGER_INITIAL_REVIEW = 1,
  MODERATION_TRIGGER_USER_FLAG = 2,
  MODERATION_TRIGGER_MACHINE_FLAG = 3,
  MODERATION_TRIGGER_MODERATOR_REVIEW = 4,
}
export enum ModerationAction { 
  MODERATION_ACTION_UNSPECIFIED = 0,
  MODERATION_ACTION_CREATE = 1,
  MODERATION_ACTION_APPROVE = 2,
  MODERATION_ACTION_HIDE = 3,
  MODERATION_ACTION_FLAG = 4,
  MODERATION_ACTION_UNFLAG = 5,
  MODERATION_ACTION_BULK_SET_VISIBILITY = 6,
  MODERATION_ACTION_SET_PRIORITY = 7,
}
export enum ModerationObjectType { 
  MODERATION_OBJECT_TYPE_UNSPECIFIED = 0,
  MODERATION_OBJECT_TYPE_HOST_REQUEST = 1,
  MODERATION_OBJECT_TYPE_GROUP_CHAT = 2,
  MODERATION_OBJECT_TYPE_FRIEND_REQUEST = 3,
  MODERATION_OBJECT_TYPE_EVENT_OCCURRENCE = 4,
  MODERATION_OBJECT_TYPE_COMMENT = 5,
  MODERATION_OBJECT_TYPE_REPLY = 6,
  MODERATION_OBJECT_TYPE_DISCUSSION = 7,
  MODERATION_OBJECT_TYPE_REFERENCE = 8,
}
