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 threads_pb from './threads_pb'; // proto import: "threads.proto"


export class EventLocation extends jspb.Message {
  getAddress(): string;
  setAddress(value: string): EventLocation;

  getLat(): number;
  setLat(value: number): EventLocation;

  getLng(): number;
  setLng(value: number): EventLocation;

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

export namespace EventLocation {
  export type AsObject = {
    address: string,
    lat: number,
    lng: number,
  }
}

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

  getIsNext(): boolean;
  setIsNext(value: boolean): Event;

  getIsCancelled(): boolean;
  setIsCancelled(value: boolean): Event;

  getIsDeleted(): boolean;
  setIsDeleted(value: boolean): Event;

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

  getSlug(): string;
  setSlug(value: string): Event;

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

  getPhotoUrl(): string;
  setPhotoUrl(value: string): Event;

  getPhotoKey(): string;
  setPhotoKey(value: string): Event;

  getLocation(): EventLocation | undefined;
  setLocation(value?: EventLocation): Event;
  hasLocation(): boolean;
  clearLocation(): Event;

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

  getLastEdited(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setLastEdited(value?: google_protobuf_timestamp_pb.Timestamp): Event;
  hasLastEdited(): boolean;
  clearLastEdited(): Event;

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

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

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

  getTimezone(): string;
  setTimezone(value: string): Event;

  getAttendanceState(): AttendanceState;
  setAttendanceState(value: AttendanceState): Event;

  getOrganizer(): boolean;
  setOrganizer(value: boolean): Event;

  getSubscriber(): boolean;
  setSubscriber(value: boolean): Event;

  getGoingCount(): number;
  setGoingCount(value: number): Event;

  getOrganizerCount(): number;
  setOrganizerCount(value: number): Event;

  getSubscriberCount(): number;
  setSubscriberCount(value: number): Event;

  getOwnerUserId(): number;
  setOwnerUserId(value: number): Event;

  getOwnerCommunityId(): number;
  setOwnerCommunityId(value: number): Event;

  getOwnerGroupId(): number;
  setOwnerGroupId(value: number): Event;

  getThread(): threads_pb.Thread | undefined;
  setThread(value?: threads_pb.Thread): Event;
  hasThread(): boolean;
  clearThread(): Event;

  getCanEdit(): boolean;
  setCanEdit(value: boolean): Event;

  getCanModerate(): boolean;
  setCanModerate(value: boolean): Event;

  getOwnerCase(): Event.OwnerCase;

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

export namespace Event {
  export type AsObject = {
    eventId: number,
    isNext: boolean,
    isCancelled: boolean,
    isDeleted: boolean,
    title: string,
    slug: string,
    content: string,
    photoUrl: string,
    photoKey: string,
    location?: EventLocation.AsObject,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    lastEdited?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    creatorUserId: number,
    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    timezone: string,
    attendanceState: AttendanceState,
    organizer: boolean,
    subscriber: boolean,
    goingCount: number,
    organizerCount: number,
    subscriberCount: number,
    ownerUserId: number,
    ownerCommunityId: number,
    ownerGroupId: number,
    thread?: threads_pb.Thread.AsObject,
    canEdit: boolean,
    canModerate: boolean,
  }

  export enum OwnerCase { 
    OWNER_NOT_SET = 0,
    OWNER_USER_ID = 28,
    OWNER_COMMUNITY_ID = 29,
    OWNER_GROUP_ID = 30,
  }
}

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

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

  getPhotoKey(): string;
  setPhotoKey(value: string): CreateEventReq;

  getLocation(): EventLocation | undefined;
  setLocation(value?: EventLocation): CreateEventReq;
  hasLocation(): boolean;
  clearLocation(): CreateEventReq;

  getParentCommunityId(): number;
  setParentCommunityId(value: number): CreateEventReq;

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

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

  getTimezone(): string;
  setTimezone(value: string): CreateEventReq;

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

export namespace CreateEventReq {
  export type AsObject = {
    title: string,
    content: string,
    photoKey: string,
    location?: EventLocation.AsObject,
    parentCommunityId: number,
    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    timezone: string,
  }
}

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

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

  getPhotoKey(): string;
  setPhotoKey(value: string): ScheduleEventReq;

  getLocation(): EventLocation | undefined;
  setLocation(value?: EventLocation): ScheduleEventReq;
  hasLocation(): boolean;
  clearLocation(): ScheduleEventReq;

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

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

  getTimezone(): string;
  setTimezone(value: string): ScheduleEventReq;

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

export namespace ScheduleEventReq {
  export type AsObject = {
    eventId: number,
    content: string,
    photoKey: string,
    location?: EventLocation.AsObject,
    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    timezone: string,
  }
}

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

  getUpdateAllFuture(): boolean;
  setUpdateAllFuture(value: boolean): UpdateEventReq;

  getTitle(): google_protobuf_wrappers_pb.StringValue | undefined;
  setTitle(value?: google_protobuf_wrappers_pb.StringValue): UpdateEventReq;
  hasTitle(): boolean;
  clearTitle(): UpdateEventReq;

  getContent(): google_protobuf_wrappers_pb.StringValue | undefined;
  setContent(value?: google_protobuf_wrappers_pb.StringValue): UpdateEventReq;
  hasContent(): boolean;
  clearContent(): UpdateEventReq;

  getPhotoKey(): google_protobuf_wrappers_pb.StringValue | undefined;
  setPhotoKey(value?: google_protobuf_wrappers_pb.StringValue): UpdateEventReq;
  hasPhotoKey(): boolean;
  clearPhotoKey(): UpdateEventReq;

  getLocation(): EventLocation | undefined;
  setLocation(value?: EventLocation): UpdateEventReq;
  hasLocation(): boolean;
  clearLocation(): UpdateEventReq;

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

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

  getTimezone(): google_protobuf_wrappers_pb.StringValue | undefined;
  setTimezone(value?: google_protobuf_wrappers_pb.StringValue): UpdateEventReq;
  hasTimezone(): boolean;
  clearTimezone(): UpdateEventReq;

  getShouldNotify(): boolean;
  setShouldNotify(value: boolean): UpdateEventReq;

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

export namespace UpdateEventReq {
  export type AsObject = {
    eventId: number,
    updateAllFuture: boolean,
    title?: google_protobuf_wrappers_pb.StringValue.AsObject,
    content?: google_protobuf_wrappers_pb.StringValue.AsObject,
    photoKey?: google_protobuf_wrappers_pb.StringValue.AsObject,
    location?: EventLocation.AsObject,
    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    timezone?: google_protobuf_wrappers_pb.StringValue.AsObject,
    shouldNotify: boolean,
  }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

export namespace ListEventAttendeesReq {
  export type AsObject = {
    eventId: number,
    pageSize: number,
    pageToken: string,
  }
}

export class ListEventAttendeesRes extends jspb.Message {
  getAttendeeUserIdsList(): Array<number>;
  setAttendeeUserIdsList(value: Array<number>): ListEventAttendeesRes;
  clearAttendeeUserIdsList(): ListEventAttendeesRes;
  addAttendeeUserIds(value: number, index?: number): ListEventAttendeesRes;

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

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

export namespace ListEventAttendeesRes {
  export type AsObject = {
    attendeeUserIdsList: Array<number>,
    nextPageToken: string,
  }
}

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

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

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

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

export namespace ListEventSubscribersReq {
  export type AsObject = {
    eventId: number,
    pageSize: number,
    pageToken: string,
  }
}

export class ListEventSubscribersRes extends jspb.Message {
  getSubscriberUserIdsList(): Array<number>;
  setSubscriberUserIdsList(value: Array<number>): ListEventSubscribersRes;
  clearSubscriberUserIdsList(): ListEventSubscribersRes;
  addSubscriberUserIds(value: number, index?: number): ListEventSubscribersRes;

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

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

export namespace ListEventSubscribersRes {
  export type AsObject = {
    subscriberUserIdsList: Array<number>,
    nextPageToken: string,
  }
}

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

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

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

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

export namespace ListEventOrganizersReq {
  export type AsObject = {
    eventId: number,
    pageSize: number,
    pageToken: string,
  }
}

export class ListEventOrganizersRes extends jspb.Message {
  getOrganizerUserIdsList(): Array<number>;
  setOrganizerUserIdsList(value: Array<number>): ListEventOrganizersRes;
  clearOrganizerUserIdsList(): ListEventOrganizersRes;
  addOrganizerUserIds(value: number, index?: number): ListEventOrganizersRes;

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

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

export namespace ListEventOrganizersRes {
  export type AsObject = {
    organizerUserIdsList: Array<number>,
    nextPageToken: string,
  }
}

export class ListMyEventsReq extends jspb.Message {
  getPast(): boolean;
  setPast(value: boolean): ListMyEventsReq;

  getSubscribed(): boolean;
  setSubscribed(value: boolean): ListMyEventsReq;

  getAttending(): boolean;
  setAttending(value: boolean): ListMyEventsReq;

  getOrganizing(): boolean;
  setOrganizing(value: boolean): ListMyEventsReq;

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

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

  getPageNumber(): number;
  setPageNumber(value: number): ListMyEventsReq;

  getMyCommunities(): boolean;
  setMyCommunities(value: boolean): ListMyEventsReq;

  getIncludeCancelled(): boolean;
  setIncludeCancelled(value: boolean): ListMyEventsReq;

  getMyCommunitiesExcludeGlobal(): boolean;
  setMyCommunitiesExcludeGlobal(value: boolean): ListMyEventsReq;

  getExcludeAttending(): boolean;
  setExcludeAttending(value: boolean): ListMyEventsReq;

  getPaginationCase(): ListMyEventsReq.PaginationCase;

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

export namespace ListMyEventsReq {
  export type AsObject = {
    past: boolean,
    subscribed: boolean,
    attending: boolean,
    organizing: boolean,
    pageSize: number,
    pageToken: string,
    pageNumber: number,
    myCommunities: boolean,
    includeCancelled: boolean,
    myCommunitiesExcludeGlobal: boolean,
    excludeAttending: boolean,
  }

  export enum PaginationCase { 
    PAGINATION_NOT_SET = 0,
    PAGE_TOKEN = 6,
    PAGE_NUMBER = 9,
  }
}

export class ListMyEventsRes extends jspb.Message {
  getEventsList(): Array<Event>;
  setEventsList(value: Array<Event>): ListMyEventsRes;
  clearEventsList(): ListMyEventsRes;
  addEvents(value?: Event, index?: number): Event;

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

  getTotalItems(): number;
  setTotalItems(value: number): ListMyEventsRes;

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

export namespace ListMyEventsRes {
  export type AsObject = {
    eventsList: Array<Event.AsObject>,
    nextPageToken: string,
    totalItems: number,
  }
}

export class ListAllEventsReq extends jspb.Message {
  getPast(): boolean;
  setPast(value: boolean): ListAllEventsReq;

  getIncludeCancelled(): boolean;
  setIncludeCancelled(value: boolean): ListAllEventsReq;

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

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

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

export namespace ListAllEventsReq {
  export type AsObject = {
    past: boolean,
    includeCancelled: boolean,
    pageSize: number,
    pageToken: string,
  }
}

export class ListAllEventsRes extends jspb.Message {
  getEventsList(): Array<Event>;
  setEventsList(value: Array<Event>): ListAllEventsRes;
  clearEventsList(): ListAllEventsRes;
  addEvents(value?: Event, index?: number): Event;

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

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

export namespace ListAllEventsRes {
  export type AsObject = {
    eventsList: Array<Event.AsObject>,
    nextPageToken: string,
  }
}

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

  getPast(): boolean;
  setPast(value: boolean): ListEventOccurrencesReq;

  getIncludeCancelled(): boolean;
  setIncludeCancelled(value: boolean): ListEventOccurrencesReq;

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

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

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

export namespace ListEventOccurrencesReq {
  export type AsObject = {
    eventId: number,
    past: boolean,
    includeCancelled: boolean,
    pageSize: number,
    pageToken: string,
  }
}

export class ListEventOccurrencesRes extends jspb.Message {
  getEventsList(): Array<Event>;
  setEventsList(value: Array<Event>): ListEventOccurrencesRes;
  clearEventsList(): ListEventOccurrencesRes;
  addEvents(value?: Event, index?: number): Event;

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

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

export namespace ListEventOccurrencesRes {
  export type AsObject = {
    eventsList: Array<Event.AsObject>,
    nextPageToken: string,
  }
}

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

  getNewOwnerCommunityId(): number;
  setNewOwnerCommunityId(value: number): TransferEventReq;

  getNewOwnerGroupId(): number;
  setNewOwnerGroupId(value: number): TransferEventReq;

  getNewOwnerCase(): TransferEventReq.NewOwnerCase;

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

export namespace TransferEventReq {
  export type AsObject = {
    eventId: number,
    newOwnerCommunityId: number,
    newOwnerGroupId: number,
  }

  export enum NewOwnerCase { 
    NEW_OWNER_NOT_SET = 0,
    NEW_OWNER_COMMUNITY_ID = 3,
    NEW_OWNER_GROUP_ID = 2,
  }
}

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

  getSubscribe(): boolean;
  setSubscribe(value: boolean): SetEventSubscriptionReq;

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

export namespace SetEventSubscriptionReq {
  export type AsObject = {
    eventId: number,
    subscribe: boolean,
  }
}

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

  getAttendanceState(): AttendanceState;
  setAttendanceState(value: AttendanceState): SetEventAttendanceReq;

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

export namespace SetEventAttendanceReq {
  export type AsObject = {
    eventId: number,
    attendanceState: AttendanceState,
  }
}

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

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

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

export namespace InviteEventOrganizerReq {
  export type AsObject = {
    eventId: number,
    userId: number,
  }
}

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

  getUserId(): google_protobuf_wrappers_pb.Int64Value | undefined;
  setUserId(value?: google_protobuf_wrappers_pb.Int64Value): RemoveEventOrganizerReq;
  hasUserId(): boolean;
  clearUserId(): RemoveEventOrganizerReq;

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

export namespace RemoveEventOrganizerReq {
  export type AsObject = {
    eventId: number,
    userId?: google_protobuf_wrappers_pb.Int64Value.AsObject,
  }
}

export enum AttendanceState { 
  ATTENDANCE_STATE_NOT_GOING = 0,
  ATTENDANCE_STATE_GOING = 2,
}
