import * as jspb from 'google-protobuf'

import * as google_api_annotations_pb from './google/api/annotations_pb'; // proto import: "google/api/annotations.proto"
import * as google_api_httpbody_pb from './google/api/httpbody_pb'; // proto import: "google/api/httpbody.proto"
import * as google_protobuf_duration_pb from 'google-protobuf/google/protobuf/duration_pb'; // proto import: "google/protobuf/duration.proto"
import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb'; // proto import: "google/protobuf/empty.proto"
import * as google_protobuf_struct_pb from 'google-protobuf/google/protobuf/struct_pb'; // proto import: "google/protobuf/struct.proto"
import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb'; // proto import: "google/protobuf/timestamp.proto"
import * as annotations_pb from './annotations_pb'; // proto import: "annotations.proto"


export class VersionInfo extends jspb.Message {
  getVersion(): string;
  setVersion(value: string): VersionInfo;

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

export namespace VersionInfo {
  export type AsObject = {
    version: string,
  }
}

export class ScreenResolution extends jspb.Message {
  getWidth(): number;
  setWidth(value: number): ScreenResolution;

  getHeight(): number;
  setHeight(value: number): ScreenResolution;

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

export namespace ScreenResolution {
  export type AsObject = {
    width: number,
    height: number,
  }
}

export class ReportBugReq extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): ReportBugReq;

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

  getResults(): string;
  setResults(value: string): ReportBugReq;

  getFrontendVersion(): string;
  setFrontendVersion(value: string): ReportBugReq;

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

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

  getScreenResolution(): ScreenResolution | undefined;
  setScreenResolution(value?: ScreenResolution): ReportBugReq;
  hasScreenResolution(): boolean;
  clearScreenResolution(): ReportBugReq;

  getSentryReplayId(): string;
  setSentryReplayId(value: string): ReportBugReq;

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

export namespace ReportBugReq {
  export type AsObject = {
    subject: string,
    description: string,
    results: string,
    frontendVersion: string,
    userAgent: string,
    page: string,
    screenResolution?: ScreenResolution.AsObject,
    sentryReplayId: string,
  }
}

export class ReportBugRes extends jspb.Message {
  getBugId(): string;
  setBugId(value: string): ReportBugRes;

  getBugUrl(): string;
  setBugUrl(value: string): ReportBugRes;

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

export namespace ReportBugRes {
  export type AsObject = {
    bugId: string,
    bugUrl: string,
  }
}

export class StatusReq extends jspb.Message {
  getNonce(): string;
  setNonce(value: string): StatusReq;

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

export namespace StatusReq {
  export type AsObject = {
    nonce: string,
  }
}

export class StatusRes extends jspb.Message {
  getNonce(): string;
  setNonce(value: string): StatusRes;

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

  getCoucherCount(): number;
  setCoucherCount(value: number): StatusRes;

  getStable(): boolean;
  setStable(value: boolean): StatusRes;

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

export namespace StatusRes {
  export type AsObject = {
    nonce: string,
    version: string,
    coucherCount: number,
    stable: boolean,
  }
}

export class GeolocationSearchInfoReq extends jspb.Message {
  getSearchString(): string;
  setSearchString(value: string): GeolocationSearchInfoReq;

  getNominatimResultJson(): string;
  setNominatimResultJson(value: string): GeolocationSearchInfoReq;

  getFormattedResultJson(): string;
  setFormattedResultJson(value: string): GeolocationSearchInfoReq;

  getDurationMs(): number;
  setDurationMs(value: number): GeolocationSearchInfoReq;

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

export namespace GeolocationSearchInfoReq {
  export type AsObject = {
    searchString: string,
    nominatimResultJson: string,
    formattedResultJson: string,
    durationMs: number,
  }
}

export class GeolocationClickInfoReq extends jspb.Message {
  getContext(): string;
  setContext(value: string): GeolocationClickInfoReq;

  getFormattedResultJson(): string;
  setFormattedResultJson(value: string): GeolocationClickInfoReq;

  getSearchChoiceJson(): string;
  setSearchChoiceJson(value: string): GeolocationClickInfoReq;

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

export namespace GeolocationClickInfoReq {
  export type AsObject = {
    context: string,
    formattedResultJson: string,
    searchChoiceJson: string,
  }
}

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

  getPropertiesJson(): string;
  setPropertiesJson(value: string): DiagnosticInfo;

  getValue(): number;
  setValue(value: number): DiagnosticInfo;

  getOccurred(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setOccurred(value?: google_protobuf_timestamp_pb.Timestamp): DiagnosticInfo;
  hasOccurred(): boolean;
  clearOccurred(): DiagnosticInfo;

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

export namespace DiagnosticInfo {
  export type AsObject = {
    tag: string,
    propertiesJson: string,
    value: number,
    occurred?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class ReportDiagnosticsReq extends jspb.Message {
  getFrontendVersion(): string;
  setFrontendVersion(value: string): ReportDiagnosticsReq;

  getInfosList(): Array<DiagnosticInfo>;
  setInfosList(value: Array<DiagnosticInfo>): ReportDiagnosticsReq;
  clearInfosList(): ReportDiagnosticsReq;
  addInfos(value?: DiagnosticInfo, index?: number): DiagnosticInfo;

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

export namespace ReportDiagnosticsReq {
  export type AsObject = {
    frontendVersion: string,
    infosList: Array<DiagnosticInfo.AsObject>,
  }
}

export class CheckNativeStatusReq extends jspb.Message {
  getDebugJson(): string;
  setDebugJson(value: string): CheckNativeStatusReq;

  getEasClientId(): string;
  setEasClientId(value: string): CheckNativeStatusReq;

  getInstallId(): string;
  setInstallId(value: string): CheckNativeStatusReq;

  getStickyId(): string;
  setStickyId(value: string): CheckNativeStatusReq;

  getIdfv(): string;
  setIdfv(value: string): CheckNativeStatusReq;

  getAndroidId(): string;
  setAndroidId(value: string): CheckNativeStatusReq;

  getDeviceName(): string;
  setDeviceName(value: string): CheckNativeStatusReq;

  getPlatform(): string;
  setPlatform(value: string): CheckNativeStatusReq;

  getOsVersion(): string;
  setOsVersion(value: string): CheckNativeStatusReq;

  getLocale(): string;
  setLocale(value: string): CheckNativeStatusReq;

  getUserState(): string;
  setUserState(value: string): CheckNativeStatusReq;

  getAppVariant(): string;
  setAppVariant(value: string): CheckNativeStatusReq;

  getAppVersion(): string;
  setAppVersion(value: string): CheckNativeStatusReq;

  getNativeBuild(): string;
  setNativeBuild(value: string): CheckNativeStatusReq;

  getEmbeddedDisplayVersion(): string;
  setEmbeddedDisplayVersion(value: string): CheckNativeStatusReq;

  getEmbeddedDebugVersion(): string;
  setEmbeddedDebugVersion(value: string): CheckNativeStatusReq;

  getRunningDisplayVersion(): string;
  setRunningDisplayVersion(value: string): CheckNativeStatusReq;

  getRunningDebugVersion(): string;
  setRunningDebugVersion(value: string): CheckNativeStatusReq;

  getRunningDebugVersionOta(): string;
  setRunningDebugVersionOta(value: string): CheckNativeStatusReq;

  getRuntimeVersion(): string;
  setRuntimeVersion(value: string): CheckNativeStatusReq;

  getUpdateId(): string;
  setUpdateId(value: string): CheckNativeStatusReq;

  getIsEmbeddedLaunch(): boolean;
  setIsEmbeddedLaunch(value: boolean): CheckNativeStatusReq;

  getLaunchSource(): string;
  setLaunchSource(value: string): CheckNativeStatusReq;

  getEmbeddedCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setEmbeddedCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): CheckNativeStatusReq;
  hasEmbeddedCreatedAt(): boolean;
  clearEmbeddedCreatedAt(): CheckNativeStatusReq;

  getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): CheckNativeStatusReq;
  hasCreatedAt(): boolean;
  clearCreatedAt(): CheckNativeStatusReq;

  getPushPermission(): string;
  setPushPermission(value: string): CheckNativeStatusReq;

  getPushToken(): string;
  setPushToken(value: string): CheckNativeStatusReq;

  getTimeSinceLastOpen(): google_protobuf_duration_pb.Duration | undefined;
  setTimeSinceLastOpen(value?: google_protobuf_duration_pb.Duration): CheckNativeStatusReq;
  hasTimeSinceLastOpen(): boolean;
  clearTimeSinceLastOpen(): CheckNativeStatusReq;

  getOccurred(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setOccurred(value?: google_protobuf_timestamp_pb.Timestamp): CheckNativeStatusReq;
  hasOccurred(): boolean;
  clearOccurred(): CheckNativeStatusReq;

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

export namespace CheckNativeStatusReq {
  export type AsObject = {
    debugJson: string,
    easClientId: string,
    installId: string,
    stickyId: string,
    idfv: string,
    androidId: string,
    deviceName: string,
    platform: string,
    osVersion: string,
    locale: string,
    userState: string,
    appVariant: string,
    appVersion: string,
    nativeBuild: string,
    embeddedDisplayVersion: string,
    embeddedDebugVersion: string,
    runningDisplayVersion: string,
    runningDebugVersion: string,
    runningDebugVersionOta: string,
    runtimeVersion: string,
    updateId: string,
    isEmbeddedLaunch: boolean,
    launchSource: string,
    embeddedCreatedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    pushPermission: string,
    pushToken: string,
    timeSinceLastOpen?: google_protobuf_duration_pb.Duration.AsObject,
    occurred?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class NativeUpdateInfo extends jspb.Message {
  getAction(): NativeUpdateAction;
  setAction(value: NativeUpdateAction): NativeUpdateInfo;

  getRequired(): boolean;
  setRequired(value: boolean): NativeUpdateInfo;

  getActBy(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setActBy(value?: google_protobuf_timestamp_pb.Timestamp): NativeUpdateInfo;
  hasActBy(): boolean;
  clearActBy(): NativeUpdateInfo;

  getNagInterval(): google_protobuf_duration_pb.Duration | undefined;
  setNagInterval(value?: google_protobuf_duration_pb.Duration): NativeUpdateInfo;
  hasNagInterval(): boolean;
  clearNagInterval(): NativeUpdateInfo;

  getMessage(): string;
  setMessage(value: string): NativeUpdateInfo;

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

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

  getCause(): NativeUpdateCause;
  setCause(value: NativeUpdateCause): NativeUpdateInfo;

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

export namespace NativeUpdateInfo {
  export type AsObject = {
    action: NativeUpdateAction,
    required: boolean,
    actBy?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    nagInterval?: google_protobuf_duration_pb.Duration.AsObject,
    message: string,
    linkUrl: string,
    linkText: string,
    cause: NativeUpdateCause,
  }
}

export class CheckNativeStatusRes extends jspb.Message {
  getUpdateInfo(): NativeUpdateInfo | undefined;
  setUpdateInfo(value?: NativeUpdateInfo): CheckNativeStatusRes;
  hasUpdateInfo(): boolean;
  clearUpdateInfo(): CheckNativeStatusRes;

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

export namespace CheckNativeStatusRes {
  export type AsObject = {
    updateInfo?: NativeUpdateInfo.AsObject,
  }
}

export class EvaluateFeatureFlagReq extends jspb.Message {
  getFlagKey(): string;
  setFlagKey(value: string): EvaluateFeatureFlagReq;

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

export namespace EvaluateFeatureFlagReq {
  export type AsObject = {
    flagKey: string,
  }
}

export class EvaluateFeatureFlagRes extends jspb.Message {
  getValue(): google_protobuf_struct_pb.Value | undefined;
  setValue(value?: google_protobuf_struct_pb.Value): EvaluateFeatureFlagRes;
  hasValue(): boolean;
  clearValue(): EvaluateFeatureFlagRes;

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

export namespace EvaluateFeatureFlagRes {
  export type AsObject = {
    value?: google_protobuf_struct_pb.Value.AsObject,
  }
}

export class LogExperimentExposureReq extends jspb.Message {
  getExperimentKey(): string;
  setExperimentKey(value: string): LogExperimentExposureReq;

  getExperimentName(): string;
  setExperimentName(value: string): LogExperimentExposureReq;

  getVariationId(): number;
  setVariationId(value: number): LogExperimentExposureReq;

  getVariationKey(): string;
  setVariationKey(value: string): LogExperimentExposureReq;

  getVariationName(): string;
  setVariationName(value: string): LogExperimentExposureReq;

  getHashAttribute(): string;
  setHashAttribute(value: string): LogExperimentExposureReq;

  getHashValue(): string;
  setHashValue(value: string): LogExperimentExposureReq;

  getFeatureId(): string;
  setFeatureId(value: string): LogExperimentExposureReq;

  getInExperiment(): boolean;
  setInExperiment(value: boolean): LogExperimentExposureReq;

  getBucket(): number;
  setBucket(value: number): LogExperimentExposureReq;
  hasBucket(): boolean;
  clearBucket(): LogExperimentExposureReq;

  getHashUsed(): boolean;
  setHashUsed(value: boolean): LogExperimentExposureReq;
  hasHashUsed(): boolean;
  clearHashUsed(): LogExperimentExposureReq;

  getStickyBucketUsed(): boolean;
  setStickyBucketUsed(value: boolean): LogExperimentExposureReq;
  hasStickyBucketUsed(): boolean;
  clearStickyBucketUsed(): LogExperimentExposureReq;

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

export namespace LogExperimentExposureReq {
  export type AsObject = {
    experimentKey: string,
    experimentName: string,
    variationId: number,
    variationKey: string,
    variationName: string,
    hashAttribute: string,
    hashValue: string,
    featureId: string,
    inExperiment: boolean,
    bucket?: number,
    hashUsed?: boolean,
    stickyBucketUsed?: boolean,
  }

  export enum BucketCase { 
    _BUCKET_NOT_SET = 0,
    BUCKET = 10,
  }

  export enum HashUsedCase { 
    _HASH_USED_NOT_SET = 0,
    HASH_USED = 11,
  }

  export enum StickyBucketUsedCase { 
    _STICKY_BUCKET_USED_NOT_SET = 0,
    STICKY_BUCKET_USED = 12,
  }
}

export enum NativeUpdateAction { 
  NATIVE_UPDATE_ACTION_UNSPECIFIED = 0,
  NATIVE_UPDATE_ACTION_NONE = 1,
  NATIVE_UPDATE_ACTION_OTA = 2,
  NATIVE_UPDATE_ACTION_STORE = 3,
  NATIVE_UPDATE_ACTION_REINSTALL = 4,
}
export enum NativeUpdateCause { 
  NATIVE_UPDATE_CAUSE_UNSPECIFIED = 0,
  NATIVE_UPDATE_CAUSE_AGE = 1,
  NATIVE_UPDATE_CAUSE_BANNED = 2,
}
