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"
import * as auth_pb from './auth_pb'; // proto import: "auth.proto"
import * as references_pb from './references_pb'; // proto import: "references.proto"


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

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

  getProfileComplete(): boolean;
  setProfileComplete(value: boolean): GetAccountInfoRes;

  getMyHomeComplete(): boolean;
  setMyHomeComplete(value: boolean): GetAccountInfoRes;

  getPhone(): string;
  setPhone(value: string): GetAccountInfoRes;

  getPhoneVerified(): boolean;
  setPhoneVerified(value: boolean): GetAccountInfoRes;

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

  getHasDonated(): boolean;
  setHasDonated(value: boolean): GetAccountInfoRes;

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

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

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

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

  getIsSuperuser(): boolean;
  setIsSuperuser(value: boolean): GetAccountInfoRes;

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

  getProfilePublicVisibility(): ProfilePublicVisibility;
  setProfilePublicVisibility(value: ProfilePublicVisibility): GetAccountInfoRes;

  getIsVolunteer(): boolean;
  setIsVolunteer(value: boolean): GetAccountInfoRes;

  getShouldShowDonationBanner(): boolean;
  setShouldShowDonationBanner(value: boolean): GetAccountInfoRes;

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

export namespace GetAccountInfoRes {
  export type AsObject = {
    username: string,
    email: string,
    profileComplete: boolean,
    myHomeComplete: boolean,
    phone: string,
    phoneVerified: boolean,
    timezone: string,
    hasDonated: boolean,
    hasStrongVerification: boolean,
    birthdateVerificationStatus: api_pb.BirthdateVerificationStatus,
    genderVerificationStatus: api_pb.GenderVerificationStatus,
    doNotEmail: boolean,
    isSuperuser: boolean,
    uiLanguagePreference: string,
    profilePublicVisibility: ProfilePublicVisibility,
    isVolunteer: boolean,
    shouldShowDonationBanner: boolean,
  }
}

export class ChangePasswordV2Req extends jspb.Message {
  getOldPassword(): string;
  setOldPassword(value: string): ChangePasswordV2Req;

  getNewPassword(): string;
  setNewPassword(value: string): ChangePasswordV2Req;

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

export namespace ChangePasswordV2Req {
  export type AsObject = {
    oldPassword: string,
    newPassword: string,
  }
}

export class ChangeEmailV2Req extends jspb.Message {
  getPassword(): string;
  setPassword(value: string): ChangeEmailV2Req;

  getNewEmail(): string;
  setNewEmail(value: string): ChangeEmailV2Req;

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

export namespace ChangeEmailV2Req {
  export type AsObject = {
    password: string,
    newEmail: string,
  }
}

export class ChangeLanguagePreferenceReq extends jspb.Message {
  getUiLanguagePreference(): string;
  setUiLanguagePreference(value: string): ChangeLanguagePreferenceReq;

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

export namespace ChangeLanguagePreferenceReq {
  export type AsObject = {
    uiLanguagePreference: string,
  }
}

export class GetContributorFormInfoRes extends jspb.Message {
  getFilledContributorForm(): boolean;
  setFilledContributorForm(value: boolean): GetContributorFormInfoRes;

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

export namespace GetContributorFormInfoRes {
  export type AsObject = {
    filledContributorForm: boolean,
  }
}

export class FillContributorFormReq extends jspb.Message {
  getContributorForm(): auth_pb.ContributorForm | undefined;
  setContributorForm(value?: auth_pb.ContributorForm): FillContributorFormReq;
  hasContributorForm(): boolean;
  clearContributorForm(): FillContributorFormReq;

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

export namespace FillContributorFormReq {
  export type AsObject = {
    contributorForm?: auth_pb.ContributorForm.AsObject,
  }
}

export class ChangePhoneReq extends jspb.Message {
  getPhone(): string;
  setPhone(value: string): ChangePhoneReq;

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

export namespace ChangePhoneReq {
  export type AsObject = {
    phone: string,
  }
}

export class VerifyPhoneReq extends jspb.Message {
  getToken(): string;
  setToken(value: string): VerifyPhoneReq;

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

export namespace VerifyPhoneReq {
  export type AsObject = {
    token: string,
  }
}

export class InitiateStrongVerificationRes extends jspb.Message {
  getVerificationAttemptToken(): string;
  setVerificationAttemptToken(value: string): InitiateStrongVerificationRes;

  getRedirectUrl(): string;
  setRedirectUrl(value: string): InitiateStrongVerificationRes;

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

export namespace InitiateStrongVerificationRes {
  export type AsObject = {
    verificationAttemptToken: string,
    redirectUrl: string,
  }
}

export class GetStrongVerificationAttemptStatusReq extends jspb.Message {
  getVerificationAttemptToken(): string;
  setVerificationAttemptToken(value: string): GetStrongVerificationAttemptStatusReq;

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

export namespace GetStrongVerificationAttemptStatusReq {
  export type AsObject = {
    verificationAttemptToken: string,
  }
}

export class GetStrongVerificationAttemptStatusRes extends jspb.Message {
  getStatus(): StrongVerificationAttemptStatus;
  setStatus(value: StrongVerificationAttemptStatus): GetStrongVerificationAttemptStatusRes;

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

export namespace GetStrongVerificationAttemptStatusRes {
  export type AsObject = {
    status: StrongVerificationAttemptStatus,
  }
}

export class DeleteAccountReq extends jspb.Message {
  getConfirm(): boolean;
  setConfirm(value: boolean): DeleteAccountReq;

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

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

export namespace DeleteAccountReq {
  export type AsObject = {
    confirm: boolean,
    reason: string,
  }
}

export class ModNote extends jspb.Message {
  getNoteId(): number;
  setNoteId(value: number): ModNote;

  getNoteContent(): string;
  setNoteContent(value: string): ModNote;

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

  getAcknowledged(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setAcknowledged(value?: google_protobuf_timestamp_pb.Timestamp): ModNote;
  hasAcknowledged(): boolean;
  clearAcknowledged(): ModNote;

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

export namespace ModNote {
  export type AsObject = {
    noteId: number,
    noteContent: string,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    acknowledged?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class ListModNotesRes extends jspb.Message {
  getModNotesList(): Array<ModNote>;
  setModNotesList(value: Array<ModNote>): ListModNotesRes;
  clearModNotesList(): ListModNotesRes;
  addModNotes(value?: ModNote, index?: number): ModNote;

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

export namespace ListModNotesRes {
  export type AsObject = {
    modNotesList: Array<ModNote.AsObject>,
  }
}

export class ListActiveSessionsReq extends jspb.Message {
  getPageSize(): number;
  setPageSize(value: number): ListActiveSessionsReq;

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

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

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

export class ActiveSession extends jspb.Message {
  getCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreated(value?: google_protobuf_timestamp_pb.Timestamp): ActiveSession;
  hasCreated(): boolean;
  clearCreated(): ActiveSession;

  getExpiry(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setExpiry(value?: google_protobuf_timestamp_pb.Timestamp): ActiveSession;
  hasExpiry(): boolean;
  clearExpiry(): ActiveSession;

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

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

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

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

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

  getIsCurrentSession(): boolean;
  setIsCurrentSession(value: boolean): ActiveSession;

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

export namespace ActiveSession {
  export type AsObject = {
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    expiry?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    lastSeen?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    operatingSystem: string,
    browser: string,
    device: string,
    approximateLocation: string,
    isCurrentSession: boolean,
  }
}

export class ListActiveSessionsRes extends jspb.Message {
  getActiveSessionsList(): Array<ActiveSession>;
  setActiveSessionsList(value: Array<ActiveSession>): ListActiveSessionsRes;
  clearActiveSessionsList(): ListActiveSessionsRes;
  addActiveSessions(value?: ActiveSession, index?: number): ActiveSession;

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

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

export namespace ListActiveSessionsRes {
  export type AsObject = {
    activeSessionsList: Array<ActiveSession.AsObject>,
    nextPageToken: string,
  }
}

export class LogOutSessionReq extends jspb.Message {
  getCreated(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreated(value?: google_protobuf_timestamp_pb.Timestamp): LogOutSessionReq;
  hasCreated(): boolean;
  clearCreated(): LogOutSessionReq;

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

export namespace LogOutSessionReq {
  export type AsObject = {
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class LogOutOtherSessionsReq extends jspb.Message {
  getConfirm(): boolean;
  setConfirm(value: boolean): LogOutOtherSessionsReq;

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

export namespace LogOutOtherSessionsReq {
  export type AsObject = {
    confirm: boolean,
  }
}

export class SetProfilePublicVisibilityReq extends jspb.Message {
  getProfilePublicVisibility(): ProfilePublicVisibility;
  setProfilePublicVisibility(value: ProfilePublicVisibility): SetProfilePublicVisibilityReq;

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

export namespace SetProfilePublicVisibilityReq {
  export type AsObject = {
    profilePublicVisibility: ProfilePublicVisibility,
  }
}

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

export namespace CreateInviteCodeReq {
  export type AsObject = {
  }
}

export class CreateInviteCodeRes extends jspb.Message {
  getCode(): string;
  setCode(value: string): CreateInviteCodeRes;

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

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

export namespace CreateInviteCodeRes {
  export type AsObject = {
    code: string,
    url: string,
  }
}

export class DisableInviteCodeReq extends jspb.Message {
  getCode(): string;
  setCode(value: string): DisableInviteCodeReq;

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

export namespace DisableInviteCodeReq {
  export type AsObject = {
    code: string,
  }
}

export class InviteCodeInfo extends jspb.Message {
  getCode(): string;
  setCode(value: string): InviteCodeInfo;

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

  getDisabled(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setDisabled(value?: google_protobuf_timestamp_pb.Timestamp): InviteCodeInfo;
  hasDisabled(): boolean;
  clearDisabled(): InviteCodeInfo;

  getUses(): number;
  setUses(value: number): InviteCodeInfo;

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

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

export namespace InviteCodeInfo {
  export type AsObject = {
    code: string,
    created?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    disabled?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    uses: number,
    url: string,
  }
}

export class ListInviteCodesRes extends jspb.Message {
  getInviteCodesList(): Array<InviteCodeInfo>;
  setInviteCodesList(value: Array<InviteCodeInfo>): ListInviteCodesRes;
  clearInviteCodesList(): ListInviteCodesRes;
  addInviteCodes(value?: InviteCodeInfo, index?: number): InviteCodeInfo;

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

export namespace ListInviteCodesRes {
  export type AsObject = {
    inviteCodesList: Array<InviteCodeInfo.AsObject>,
  }
}

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

export namespace CompleteProfileReminder {
  export type AsObject = {
  }
}

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

export namespace CompleteMyHomeReminder {
  export type AsObject = {
  }
}

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

export namespace CompleteVerificationReminder {
  export type AsObject = {
  }
}

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

  getSurferUser(): api_pb.LiteUser | undefined;
  setSurferUser(value?: api_pb.LiteUser): RespondToHostRequestReminder;
  hasSurferUser(): boolean;
  clearSurferUser(): RespondToHostRequestReminder;

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

export namespace RespondToHostRequestReminder {
  export type AsObject = {
    hostRequestId: number,
    surferUser?: api_pb.LiteUser.AsObject,
  }
}

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

  getHostUser(): api_pb.LiteUser | undefined;
  setHostUser(value?: api_pb.LiteUser): ConfirmHostRequestReminder;
  hasHostUser(): boolean;
  clearHostUser(): ConfirmHostRequestReminder;

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

export namespace ConfirmHostRequestReminder {
  export type AsObject = {
    hostRequestId: number,
    hostUser?: api_pb.LiteUser.AsObject,
  }
}

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

  getOtherUser(): api_pb.LiteUser | undefined;
  setOtherUser(value?: api_pb.LiteUser): WriteReferenceReminder;
  hasOtherUser(): boolean;
  clearOtherUser(): WriteReferenceReminder;

  getReferenceType(): references_pb.ReferenceType;
  setReferenceType(value: references_pb.ReferenceType): WriteReferenceReminder;

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

export namespace WriteReferenceReminder {
  export type AsObject = {
    hostRequestId: number,
    otherUser?: api_pb.LiteUser.AsObject,
    referenceType: references_pb.ReferenceType,
  }
}

export class Reminder extends jspb.Message {
  getCompleteProfileReminder(): CompleteProfileReminder | undefined;
  setCompleteProfileReminder(value?: CompleteProfileReminder): Reminder;
  hasCompleteProfileReminder(): boolean;
  clearCompleteProfileReminder(): Reminder;

  getCompleteVerificationReminder(): CompleteVerificationReminder | undefined;
  setCompleteVerificationReminder(value?: CompleteVerificationReminder): Reminder;
  hasCompleteVerificationReminder(): boolean;
  clearCompleteVerificationReminder(): Reminder;

  getRespondToHostRequestReminder(): RespondToHostRequestReminder | undefined;
  setRespondToHostRequestReminder(value?: RespondToHostRequestReminder): Reminder;
  hasRespondToHostRequestReminder(): boolean;
  clearRespondToHostRequestReminder(): Reminder;

  getWriteReferenceReminder(): WriteReferenceReminder | undefined;
  setWriteReferenceReminder(value?: WriteReferenceReminder): Reminder;
  hasWriteReferenceReminder(): boolean;
  clearWriteReferenceReminder(): Reminder;

  getCompleteMyHomeReminder(): CompleteMyHomeReminder | undefined;
  setCompleteMyHomeReminder(value?: CompleteMyHomeReminder): Reminder;
  hasCompleteMyHomeReminder(): boolean;
  clearCompleteMyHomeReminder(): Reminder;

  getConfirmHostRequestReminder(): ConfirmHostRequestReminder | undefined;
  setConfirmHostRequestReminder(value?: ConfirmHostRequestReminder): Reminder;
  hasConfirmHostRequestReminder(): boolean;
  clearConfirmHostRequestReminder(): Reminder;

  getReminderCase(): Reminder.ReminderCase;

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

export namespace Reminder {
  export type AsObject = {
    completeProfileReminder?: CompleteProfileReminder.AsObject,
    completeVerificationReminder?: CompleteVerificationReminder.AsObject,
    respondToHostRequestReminder?: RespondToHostRequestReminder.AsObject,
    writeReferenceReminder?: WriteReferenceReminder.AsObject,
    completeMyHomeReminder?: CompleteMyHomeReminder.AsObject,
    confirmHostRequestReminder?: ConfirmHostRequestReminder.AsObject,
  }

  export enum ReminderCase { 
    REMINDER_NOT_SET = 0,
    COMPLETE_PROFILE_REMINDER = 1,
    COMPLETE_VERIFICATION_REMINDER = 2,
    RESPOND_TO_HOST_REQUEST_REMINDER = 3,
    WRITE_REFERENCE_REMINDER = 4,
    COMPLETE_MY_HOME_REMINDER = 5,
    CONFIRM_HOST_REQUEST_REMINDER = 6,
  }
}

export class GetRemindersRes extends jspb.Message {
  getRemindersList(): Array<Reminder>;
  setRemindersList(value: Array<Reminder>): GetRemindersRes;
  clearRemindersList(): GetRemindersRes;
  addReminders(value?: Reminder, index?: number): Reminder;

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

export namespace GetRemindersRes {
  export type AsObject = {
    remindersList: Array<Reminder.AsObject>,
  }
}

export class GetMyVolunteerInfoRes extends jspb.Message {
  getDisplayName(): string;
  setDisplayName(value: string): GetMyVolunteerInfoRes;

  getDisplayLocation(): string;
  setDisplayLocation(value: string): GetMyVolunteerInfoRes;

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

  getStartedVolunteering(): string;
  setStartedVolunteering(value: string): GetMyVolunteerInfoRes;

  getStoppedVolunteering(): string;
  setStoppedVolunteering(value: string): GetMyVolunteerInfoRes;

  getShowOnTeamPage(): boolean;
  setShowOnTeamPage(value: boolean): GetMyVolunteerInfoRes;

  getLinkType(): string;
  setLinkType(value: string): GetMyVolunteerInfoRes;

  getLinkText(): string;
  setLinkText(value: string): GetMyVolunteerInfoRes;

  getLinkUrl(): string;
  setLinkUrl(value: string): GetMyVolunteerInfoRes;

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

export namespace GetMyVolunteerInfoRes {
  export type AsObject = {
    displayName: string,
    displayLocation: string,
    role: string,
    startedVolunteering: string,
    stoppedVolunteering: string,
    showOnTeamPage: boolean,
    linkType: string,
    linkText: string,
    linkUrl: string,
  }
}

export class UpdateMyVolunteerInfoReq extends jspb.Message {
  getDisplayName(): google_protobuf_wrappers_pb.StringValue | undefined;
  setDisplayName(value?: google_protobuf_wrappers_pb.StringValue): UpdateMyVolunteerInfoReq;
  hasDisplayName(): boolean;
  clearDisplayName(): UpdateMyVolunteerInfoReq;

  getDisplayLocation(): google_protobuf_wrappers_pb.StringValue | undefined;
  setDisplayLocation(value?: google_protobuf_wrappers_pb.StringValue): UpdateMyVolunteerInfoReq;
  hasDisplayLocation(): boolean;
  clearDisplayLocation(): UpdateMyVolunteerInfoReq;

  getShowOnTeamPage(): google_protobuf_wrappers_pb.BoolValue | undefined;
  setShowOnTeamPage(value?: google_protobuf_wrappers_pb.BoolValue): UpdateMyVolunteerInfoReq;
  hasShowOnTeamPage(): boolean;
  clearShowOnTeamPage(): UpdateMyVolunteerInfoReq;

  getLinkType(): google_protobuf_wrappers_pb.StringValue | undefined;
  setLinkType(value?: google_protobuf_wrappers_pb.StringValue): UpdateMyVolunteerInfoReq;
  hasLinkType(): boolean;
  clearLinkType(): UpdateMyVolunteerInfoReq;

  getLinkText(): google_protobuf_wrappers_pb.StringValue | undefined;
  setLinkText(value?: google_protobuf_wrappers_pb.StringValue): UpdateMyVolunteerInfoReq;
  hasLinkText(): boolean;
  clearLinkText(): UpdateMyVolunteerInfoReq;

  getLinkUrl(): google_protobuf_wrappers_pb.StringValue | undefined;
  setLinkUrl(value?: google_protobuf_wrappers_pb.StringValue): UpdateMyVolunteerInfoReq;
  hasLinkUrl(): boolean;
  clearLinkUrl(): UpdateMyVolunteerInfoReq;

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

export namespace UpdateMyVolunteerInfoReq {
  export type AsObject = {
    displayName?: google_protobuf_wrappers_pb.StringValue.AsObject,
    displayLocation?: google_protobuf_wrappers_pb.StringValue.AsObject,
    showOnTeamPage?: google_protobuf_wrappers_pb.BoolValue.AsObject,
    linkType?: google_protobuf_wrappers_pb.StringValue.AsObject,
    linkText?: google_protobuf_wrappers_pb.StringValue.AsObject,
    linkUrl?: google_protobuf_wrappers_pb.StringValue.AsObject,
  }
}

export enum StrongVerificationAttemptStatus { 
  STRONG_VERIFICATION_ATTEMPT_STATUS_UNKNOWN = 0,
  STRONG_VERIFICATION_ATTEMPT_STATUS_SUCCEEDED = 1,
  STRONG_VERIFICATION_ATTEMPT_STATUS_IN_PROGRESS_WAITING_ON_USER_TO_OPEN_APP = 2,
  STRONG_VERIFICATION_ATTEMPT_STATUS_IN_PROGRESS_WAITING_ON_USER_IN_APP = 5,
  STRONG_VERIFICATION_ATTEMPT_STATUS_IN_PROGRESS_WAITING_ON_BACKEND = 3,
  STRONG_VERIFICATION_ATTEMPT_STATUS_FAILED = 4,
}
export enum ProfilePublicVisibility { 
  PROFILE_PUBLIC_VISIBILITY_UNKNOWN = 0,
  PROFILE_PUBLIC_VISIBILITY_NOTHING = 1,
  PROFILE_PUBLIC_VISIBILITY_MAP_ONLY = 2,
  PROFILE_PUBLIC_VISIBILITY_LIMITED = 3,
  PROFILE_PUBLIC_VISIBILITY_MOST = 4,
  PROFILE_PUBLIC_VISIBILITY_FULL = 5,
}
