// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.2.0
//   protoc               v5.28.0
// source: youtube/api/pfiinnertube/client_info.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";

export const protobufPackage = "youtube.api.pfiinnertube";

export interface ClientInfo {
  hl?: string | undefined;
  gl?: string | undefined;
  remoteHost?: string | undefined;
  deviceId?: string | undefined;
  debugDeviceIdOverride?: string | undefined;
  carrierGeo?: string | undefined;
  crackedHl?: boolean | undefined;
  deviceMake?: string | undefined;
  deviceModel?: string | undefined;
  visitorData?: string | undefined;
  userAgent?: string | undefined;
  clientName?: number | undefined;
  clientVersion?: string | undefined;
  osName?: string | undefined;
  osVersion?: string | undefined;
  projectId?: string | undefined;
  acceptLanguage?: string | undefined;
  acceptRegion?: string | undefined;
  originalUrl?: string | undefined;
  rawDeviceId?: string | undefined;
  configData?: string | undefined;
  spacecastToken?: string | undefined;
  internalGeo?: string | undefined;
  screenWidthPoints?: number | undefined;
  screenHeightPoints?: number | undefined;
  screenWidthInches?: number | undefined;
  screenHeightInches?: number | undefined;
  screenPixelDensity?: number | undefined;
  platform?: number | undefined;
  spacecastClientInfo?: ClientInfo_SpacecastClientInfo | undefined;
  clientFormFactor?: ClientInfo_ClientFormFactor | undefined;
  forwardedFor?: string | undefined;
  mobileDataPlanInfo?:
    | ClientInfo_MobileDataPlanInfo
    | undefined;
  /** e.g. 241757026 */
  gmscoreVersionCode?: number | undefined;
  webpSupport?: boolean | undefined;
  cameraType?: ClientInfo_CameraType | undefined;
  experimentsToken?: string | undefined;
  windowWidthPoints?: number | undefined;
  windowHeightPoints?: number | undefined;
  configInfo?: ClientInfo_ConfigGroupsClientInfo | undefined;
  unpluggedLocationInfo?: ClientInfo_UnpluggedLocationInfo | undefined;
  androidSdkVersion?: number | undefined;
  screenDensityFloat?: number | undefined;
  firstTimeSignInExperimentIds?: number | undefined;
  utcOffsetMinutes?: number | undefined;
  animatedWebpSupport?: boolean | undefined;
  kidsAppInfo?: ClientInfo_KidsAppInfo | undefined;
  musicAppInfo?: ClientInfo_MusicAppInfo | undefined;
  tvAppInfo?: ClientInfo_TvAppInfo | undefined;
  internalGeoIp?: string | undefined;
  unpluggedAppInfo?: ClientInfo_UnpluggedAppInfo | undefined;
  locationInfo?: ClientInfo_LocationInfo | undefined;
  contentSizeCategory?: string | undefined;
  fontScale?: number | undefined;
  userInterfaceTheme?: ClientInfo_UserInterfaceTheme | undefined;
  timeZone?: string | undefined;
  homeGroupInfo?: ClientInfo_HomeGroupInfo | undefined;
  emlTemplateContext?: Uint8Array | undefined;
  coldAppBundleConfigData?:
    | Uint8Array
    | undefined;
  /** repeated ExperimentsHeterodyne.ExperimentIds heterodyne_ids = 86; */
  browserName?: string | undefined;
  browserVersion?: string | undefined;
  locationPlayabilityToken?:
    | string
    | undefined;
  /** e.g. "qcom;taro" */
  chipset?: string | undefined;
  firmwareVersion?: string | undefined;
  memoryTotalKbytes?: number | undefined;
  mainAppWebInfo?: ClientInfo_MainAppWebInfo | undefined;
  notificationPermissionInfo?: ClientInfo_NotificationPermissionInfo | undefined;
  deviceBrand?:
    | string
    | undefined;
  /**
   * optional ClientStoreInfo client_store_info = 99;
   * optional SRSDataPushVersion srs_datapush_build_ids = 100;
   * optional PlayerDataPushVersion player_datapush_build_ids = 101;
   */
  glDeviceInfo?: ClientInfo_GLDeviceInfo | undefined;
}

export enum ClientInfo_ClientFormFactor {
  /** UNKNOWN_FORM_FACTOR - @TODO: Check these. */
  UNKNOWN_FORM_FACTOR = 0,
  FORM_FACTOR_VAL1 = 1,
  FORM_FACTOR_VAL2 = 2,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_CameraType {
  UNKNOWN_CAMERA_TYPE = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_UserInterfaceTheme {
  USER_INTERFACE_THEME_DARK = 0,
  USER_INTERFACE_THEME_LIGHT = 1,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_MainAppWebInfo {
  graftUrl?: string | undefined;
  pwaInstallabilityStatus?: ClientInfo_MainAppWebInfo_PwaInstallabilityStatus | undefined;
  webDisplayMode?: ClientInfo_MainAppWebInfo_WebDisplayMode | undefined;
  isWebNativeShareAvailable?: boolean | undefined;
  storeDigitalGoodsApiSupportStatus?: ClientInfo_MainAppWebInfo_StoreDigitalGoodsApiSupportStatus | undefined;
}

export enum ClientInfo_MainAppWebInfo_StoreDigitalGoodsApiSupportStatus {
  STORE_DIGITAL_GOODS_API_SUPPORT_STATUS_VAL0 = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MainAppWebInfo_PwaInstallabilityStatus {
  PWA_INSTALLABILITY_STATUS_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MainAppWebInfo_WebDisplayMode {
  WEB_DISPLAY_MODE_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_NotificationPermissionInfo {
  notificationsSetting?: ClientInfo_NotificationPermissionInfo_NotificationsSetting | undefined;
  lastDeviceOptInChangeTimeAgoSec?: number | undefined;
}

export enum ClientInfo_NotificationPermissionInfo_NotificationsSetting {
  NOTIFICATIONS_SETTING_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_GLDeviceInfo {
  glRenderer?: string | undefined;
  glEsVersionMajor?: number | undefined;
  glEsVersionMinor?: number | undefined;
}

export interface ClientInfo_SpacecastClientInfo {
  appliances?: ClientInfo_SpacecastClientInfo_SpacecastAppliance | undefined;
  interactionLevel?: ClientInfo_SpacecastClientInfo_SpacecastInteractionLevel | undefined;
}

export enum ClientInfo_SpacecastClientInfo_SpacecastInteractionLevel {
  UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_SpacecastClientInfo_SpacecastAppliance {
  contentProfileToken?: Uint8Array | undefined;
  status?: ClientInfo_SpacecastClientInfo_SpacecastAppliance_OperationalStatus | undefined;
  hostname?: string | undefined;
  active?: boolean | undefined;
  deviceId?: string | undefined;
}

export enum ClientInfo_SpacecastClientInfo_SpacecastAppliance_OperationalStatus {
  UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_MobileDataPlanInfo {
  cpid?: string | undefined;
  serializedDataPlanStatus?: string | undefined;
  dataSavingQualityPickerEnabled?: boolean | undefined;
  mccmnc?: string | undefined;
}

export interface ClientInfo_ConfigGroupsClientInfo {
  coldConfigData?: string | undefined;
  coldHashData?: string | undefined;
  hotHashData?: string | undefined;
  appInstallData?: string | undefined;
}

export interface ClientInfo_UnpluggedLocationInfo {
  latitudeE7?: number | undefined;
  longitudeE7?: number | undefined;
  localTimestampMs?: number | undefined;
  ipAddress?: string | undefined;
  timezone?: string | undefined;
  prefer24HourTime?: boolean | undefined;
  locationRadiusMeters?: number | undefined;
  isInitialLoad?: boolean | undefined;
  browserPermissionGranted?: boolean | undefined;
  clientPermissionState?: number | undefined;
  locationOverrideToken?: string | undefined;
}

export interface ClientInfo_KidsAppInfo {
  contentSettings?: ClientInfo_KidsAppInfo_KidsContentSettings | undefined;
  parentCurationMode?: ClientInfo_KidsAppInfo_KidsParentCurationMode | undefined;
  categorySettings?: ClientInfo_KidsAppInfo_KidsCategorySettings | undefined;
  userEducationSettings?: ClientInfo_KidsAppInfo_KidsUserEducationSettings | undefined;
}

export enum ClientInfo_KidsAppInfo_KidsParentCurationMode {
  KPCM_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_KidsAppInfo_KidsContentSettings {
  kidsNoSearchMode?: ClientInfo_KidsAppInfo_KidsContentSettings_YTKidsNoSearchMode | undefined;
  ageUpMode?: ClientInfo_KidsAppInfo_KidsContentSettings_YTKidsAgeUpMode | undefined;
  contentDensity?: ClientInfo_KidsAppInfo_KidsContentSettings_KidsContentDensity | undefined;
}

export enum ClientInfo_KidsAppInfo_KidsContentSettings_YTKidsNoSearchMode {
  YT_KIDS_NO_SEARCH_MODE_OFF = 0,
  YT_KIDS_NO_SEARCH_MODE_ON = 1,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_KidsAppInfo_KidsContentSettings_YTKidsAgeUpMode {
  YT_KIDS_AGE_UP_MODE_OFF = 0,
  YT_KIDS_AGE_UP_MODE_ON = 1,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_KidsAppInfo_KidsContentSettings_KidsContentDensity {
  /** YT_KIDS_CONTENT_DENSITY_VAL1 - @TODO: Check these. */
  YT_KIDS_CONTENT_DENSITY_VAL1 = 0,
  YT_KIDS_CONTENT_DENSITY_VAL2 = 1,
  YT_KIDS_CONTENT_DENSITY_VAL3 = 2,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_KidsAppInfo_KidsCategorySettings {
  enabledCategories?: string | undefined;
}

export interface ClientInfo_KidsAppInfo_KidsUserEducationSettings {
  hasSeenHomeChipBarUserEducation?: boolean | undefined;
  hasSeenHomePivotBarUserEducation?: boolean | undefined;
  hasSeenParentMuirUserEducation?: boolean | undefined;
}

export interface ClientInfo_MusicAppInfo {
  playBackMode?: ClientInfo_MusicAppInfo_MusicPlayBackMode | undefined;
  musicLocationMasterSwitch?: ClientInfo_MusicAppInfo_MusicLocationMasterSwitch | undefined;
  musicActivityMasterSwitch?: ClientInfo_MusicAppInfo_MusicActivityMasterSwitch | undefined;
  offlineMixtapeEnabled?: boolean | undefined;
  autoOfflineEnabled?: boolean | undefined;
  iosBackgroundRefreshStatus?: ClientInfo_MusicAppInfo_IosBackgroundRefreshStatus | undefined;
  smartDownloadsSongLimit?: number | undefined;
  transitionedFromMixtapeToSmartDownloads?: boolean | undefined;
  pwaInstallabilityStatus?: ClientInfo_MusicAppInfo_PwaInstallabilityStatus | undefined;
  webDisplayMode?: ClientInfo_MusicAppInfo_WebDisplayMode | undefined;
  musicTier?: ClientInfo_MusicAppInfo_MusicTier | undefined;
  storeDigitalGoodsApiSupportStatus?: ClientInfo_MusicAppInfo_StoreDigitalGoodsApiSupportStatus | undefined;
  smartDownloadsTimeSinceLastOptOutSec?: number | undefined;
}

export enum ClientInfo_MusicAppInfo_MusicPlayBackMode {
  MPBM_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_MusicLocationMasterSwitch {
  MLMS_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_MusicActivityMasterSwitch {
  MAMS_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_IosBackgroundRefreshStatus {
  UNKNOWN_STATUS = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_PwaInstallabilityStatus {
  PIS_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_WebDisplayMode {
  WDM_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_MusicTier {
  UNKNOWN_TIER = 0,
  UNRECOGNIZED = -1,
}

export enum ClientInfo_MusicAppInfo_StoreDigitalGoodsApiSupportStatus {
  SDGAS_UNKNOWN = 0,
  UNRECOGNIZED = -1,
}

export interface ClientInfo_TvAppInfo {
  mdxImpactedSessionsServerEvents?: string | undefined;
  enablePrivacyFilter?: boolean | undefined;
  zylonLeftNav?: boolean | undefined;
  certificationScope?: string | undefined;
  livingRoomPoTokenId?: string | undefined;
  jsEngineString?: string | undefined;
  voiceCapability?: ClientInfo_TvAppInfo_VoiceCapability | undefined;
  systemIntegrator?: string | undefined;
  androidBuildFingerprint?: string | undefined;
  cobaltAppVersion?: string | undefined;
  cobaltStarboardVersion?: string | undefined;
  useStartPlaybackPreviewCommand?: boolean | undefined;
  shouldShowPersistentSigninOnHome?: boolean | undefined;
  androidPlayServicesVersion?: string | undefined;
}

export interface ClientInfo_TvAppInfo_VoiceCapability {
  hasSoftMicSupport?: boolean | undefined;
  hasHardMicSupport?: boolean | undefined;
}

export interface ClientInfo_UnpluggedAppInfo {
  enableFilterMode?: boolean | undefined;
  iosNotificationPermission?: boolean | undefined;
  forceEnableEpg3?: boolean | undefined;
}

export interface ClientInfo_LocationInfo {
  locationInfoStatus?: number | undefined;
  ulrStatus?: ClientInfo_LocationInfo_UrlStatus | undefined;
  latitudeE7?: string | undefined;
  longitudeE7?: string | undefined;
  horizontalAccuracyMeters?: string | undefined;
  locationFreshnessMs?: string | undefined;
  locationPermissionAuthorizationStatus?: number | undefined;
  locationOverrideToken?: string | undefined;
  forceLocationPlayabilityTokenRefresh?: boolean | undefined;
}

export interface ClientInfo_LocationInfo_UrlStatus {
  reportingEnabledSetting?: number | undefined;
  historyEnabledSetting?: number | undefined;
  isAllowed?: boolean | undefined;
  isActive?: boolean | undefined;
}

export interface ClientInfo_HomeGroupInfo {
  isPartOfGroup?: boolean | undefined;
  isGroup?: boolean | undefined;
}

function createBaseClientInfo(): ClientInfo {
  return {
    hl: undefined,
    gl: undefined,
    remoteHost: undefined,
    deviceId: undefined,
    debugDeviceIdOverride: undefined,
    carrierGeo: undefined,
    crackedHl: undefined,
    deviceMake: undefined,
    deviceModel: undefined,
    visitorData: undefined,
    userAgent: undefined,
    clientName: undefined,
    clientVersion: undefined,
    osName: undefined,
    osVersion: undefined,
    projectId: undefined,
    acceptLanguage: undefined,
    acceptRegion: undefined,
    originalUrl: undefined,
    rawDeviceId: undefined,
    configData: undefined,
    spacecastToken: undefined,
    internalGeo: undefined,
    screenWidthPoints: undefined,
    screenHeightPoints: undefined,
    screenWidthInches: undefined,
    screenHeightInches: undefined,
    screenPixelDensity: undefined,
    platform: undefined,
    spacecastClientInfo: undefined,
    clientFormFactor: undefined,
    forwardedFor: undefined,
    mobileDataPlanInfo: undefined,
    gmscoreVersionCode: undefined,
    webpSupport: undefined,
    cameraType: undefined,
    experimentsToken: undefined,
    windowWidthPoints: undefined,
    windowHeightPoints: undefined,
    configInfo: undefined,
    unpluggedLocationInfo: undefined,
    androidSdkVersion: undefined,
    screenDensityFloat: undefined,
    firstTimeSignInExperimentIds: undefined,
    utcOffsetMinutes: undefined,
    animatedWebpSupport: undefined,
    kidsAppInfo: undefined,
    musicAppInfo: undefined,
    tvAppInfo: undefined,
    internalGeoIp: undefined,
    unpluggedAppInfo: undefined,
    locationInfo: undefined,
    contentSizeCategory: undefined,
    fontScale: undefined,
    userInterfaceTheme: undefined,
    timeZone: undefined,
    homeGroupInfo: undefined,
    emlTemplateContext: undefined,
    coldAppBundleConfigData: undefined,
    browserName: undefined,
    browserVersion: undefined,
    locationPlayabilityToken: undefined,
    chipset: undefined,
    firmwareVersion: undefined,
    memoryTotalKbytes: undefined,
    mainAppWebInfo: undefined,
    notificationPermissionInfo: undefined,
    deviceBrand: undefined,
    glDeviceInfo: undefined,
  };
}

export const ClientInfo: MessageFns<ClientInfo> = {
  encode(message: ClientInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.hl !== undefined) {
      writer.uint32(10).string(message.hl);
    }
    if (message.gl !== undefined) {
      writer.uint32(18).string(message.gl);
    }
    if (message.remoteHost !== undefined) {
      writer.uint32(34).string(message.remoteHost);
    }
    if (message.deviceId !== undefined) {
      writer.uint32(50).string(message.deviceId);
    }
    if (message.debugDeviceIdOverride !== undefined) {
      writer.uint32(66).string(message.debugDeviceIdOverride);
    }
    if (message.carrierGeo !== undefined) {
      writer.uint32(82).string(message.carrierGeo);
    }
    if (message.crackedHl !== undefined) {
      writer.uint32(88).bool(message.crackedHl);
    }
    if (message.deviceMake !== undefined) {
      writer.uint32(98).string(message.deviceMake);
    }
    if (message.deviceModel !== undefined) {
      writer.uint32(106).string(message.deviceModel);
    }
    if (message.visitorData !== undefined) {
      writer.uint32(114).string(message.visitorData);
    }
    if (message.userAgent !== undefined) {
      writer.uint32(122).string(message.userAgent);
    }
    if (message.clientName !== undefined) {
      writer.uint32(128).int32(message.clientName);
    }
    if (message.clientVersion !== undefined) {
      writer.uint32(138).string(message.clientVersion);
    }
    if (message.osName !== undefined) {
      writer.uint32(146).string(message.osName);
    }
    if (message.osVersion !== undefined) {
      writer.uint32(154).string(message.osVersion);
    }
    if (message.projectId !== undefined) {
      writer.uint32(162).string(message.projectId);
    }
    if (message.acceptLanguage !== undefined) {
      writer.uint32(170).string(message.acceptLanguage);
    }
    if (message.acceptRegion !== undefined) {
      writer.uint32(178).string(message.acceptRegion);
    }
    if (message.originalUrl !== undefined) {
      writer.uint32(186).string(message.originalUrl);
    }
    if (message.rawDeviceId !== undefined) {
      writer.uint32(202).string(message.rawDeviceId);
    }
    if (message.configData !== undefined) {
      writer.uint32(218).string(message.configData);
    }
    if (message.spacecastToken !== undefined) {
      writer.uint32(250).string(message.spacecastToken);
    }
    if (message.internalGeo !== undefined) {
      writer.uint32(274).string(message.internalGeo);
    }
    if (message.screenWidthPoints !== undefined) {
      writer.uint32(296).int32(message.screenWidthPoints);
    }
    if (message.screenHeightPoints !== undefined) {
      writer.uint32(304).int32(message.screenHeightPoints);
    }
    if (message.screenWidthInches !== undefined) {
      writer.uint32(317).float(message.screenWidthInches);
    }
    if (message.screenHeightInches !== undefined) {
      writer.uint32(325).float(message.screenHeightInches);
    }
    if (message.screenPixelDensity !== undefined) {
      writer.uint32(328).int32(message.screenPixelDensity);
    }
    if (message.platform !== undefined) {
      writer.uint32(336).int32(message.platform);
    }
    if (message.spacecastClientInfo !== undefined) {
      ClientInfo_SpacecastClientInfo.encode(message.spacecastClientInfo, writer.uint32(362).fork()).join();
    }
    if (message.clientFormFactor !== undefined) {
      writer.uint32(368).int32(message.clientFormFactor);
    }
    if (message.forwardedFor !== undefined) {
      writer.uint32(386).string(message.forwardedFor);
    }
    if (message.mobileDataPlanInfo !== undefined) {
      ClientInfo_MobileDataPlanInfo.encode(message.mobileDataPlanInfo, writer.uint32(394).fork()).join();
    }
    if (message.gmscoreVersionCode !== undefined) {
      writer.uint32(400).int32(message.gmscoreVersionCode);
    }
    if (message.webpSupport !== undefined) {
      writer.uint32(408).bool(message.webpSupport);
    }
    if (message.cameraType !== undefined) {
      writer.uint32(416).int32(message.cameraType);
    }
    if (message.experimentsToken !== undefined) {
      writer.uint32(434).string(message.experimentsToken);
    }
    if (message.windowWidthPoints !== undefined) {
      writer.uint32(440).int32(message.windowWidthPoints);
    }
    if (message.windowHeightPoints !== undefined) {
      writer.uint32(448).int32(message.windowHeightPoints);
    }
    if (message.configInfo !== undefined) {
      ClientInfo_ConfigGroupsClientInfo.encode(message.configInfo, writer.uint32(498).fork()).join();
    }
    if (message.unpluggedLocationInfo !== undefined) {
      ClientInfo_UnpluggedLocationInfo.encode(message.unpluggedLocationInfo, writer.uint32(506).fork()).join();
    }
    if (message.androidSdkVersion !== undefined) {
      writer.uint32(512).int32(message.androidSdkVersion);
    }
    if (message.screenDensityFloat !== undefined) {
      writer.uint32(525).float(message.screenDensityFloat);
    }
    if (message.firstTimeSignInExperimentIds !== undefined) {
      writer.uint32(528).int32(message.firstTimeSignInExperimentIds);
    }
    if (message.utcOffsetMinutes !== undefined) {
      writer.uint32(536).int32(message.utcOffsetMinutes);
    }
    if (message.animatedWebpSupport !== undefined) {
      writer.uint32(544).bool(message.animatedWebpSupport);
    }
    if (message.kidsAppInfo !== undefined) {
      ClientInfo_KidsAppInfo.encode(message.kidsAppInfo, writer.uint32(554).fork()).join();
    }
    if (message.musicAppInfo !== undefined) {
      ClientInfo_MusicAppInfo.encode(message.musicAppInfo, writer.uint32(562).fork()).join();
    }
    if (message.tvAppInfo !== undefined) {
      ClientInfo_TvAppInfo.encode(message.tvAppInfo, writer.uint32(570).fork()).join();
    }
    if (message.internalGeoIp !== undefined) {
      writer.uint32(578).string(message.internalGeoIp);
    }
    if (message.unpluggedAppInfo !== undefined) {
      ClientInfo_UnpluggedAppInfo.encode(message.unpluggedAppInfo, writer.uint32(586).fork()).join();
    }
    if (message.locationInfo !== undefined) {
      ClientInfo_LocationInfo.encode(message.locationInfo, writer.uint32(594).fork()).join();
    }
    if (message.contentSizeCategory !== undefined) {
      writer.uint32(610).string(message.contentSizeCategory);
    }
    if (message.fontScale !== undefined) {
      writer.uint32(621).float(message.fontScale);
    }
    if (message.userInterfaceTheme !== undefined) {
      writer.uint32(624).int32(message.userInterfaceTheme);
    }
    if (message.timeZone !== undefined) {
      writer.uint32(642).string(message.timeZone);
    }
    if (message.homeGroupInfo !== undefined) {
      ClientInfo_HomeGroupInfo.encode(message.homeGroupInfo, writer.uint32(650).fork()).join();
    }
    if (message.emlTemplateContext !== undefined) {
      writer.uint32(674).bytes(message.emlTemplateContext);
    }
    if (message.coldAppBundleConfigData !== undefined) {
      writer.uint32(682).bytes(message.coldAppBundleConfigData);
    }
    if (message.browserName !== undefined) {
      writer.uint32(698).string(message.browserName);
    }
    if (message.browserVersion !== undefined) {
      writer.uint32(706).string(message.browserVersion);
    }
    if (message.locationPlayabilityToken !== undefined) {
      writer.uint32(714).string(message.locationPlayabilityToken);
    }
    if (message.chipset !== undefined) {
      writer.uint32(738).string(message.chipset);
    }
    if (message.firmwareVersion !== undefined) {
      writer.uint32(746).string(message.firmwareVersion);
    }
    if (message.memoryTotalKbytes !== undefined) {
      writer.uint32(760).int64(message.memoryTotalKbytes);
    }
    if (message.mainAppWebInfo !== undefined) {
      ClientInfo_MainAppWebInfo.encode(message.mainAppWebInfo, writer.uint32(770).fork()).join();
    }
    if (message.notificationPermissionInfo !== undefined) {
      ClientInfo_NotificationPermissionInfo.encode(message.notificationPermissionInfo, writer.uint32(778).fork())
        .join();
    }
    if (message.deviceBrand !== undefined) {
      writer.uint32(786).string(message.deviceBrand);
    }
    if (message.glDeviceInfo !== undefined) {
      ClientInfo_GLDeviceInfo.encode(message.glDeviceInfo, writer.uint32(818).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.hl = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }

          message.gl = reader.string();
          continue;
        case 4:
          if (tag !== 34) {
            break;
          }

          message.remoteHost = reader.string();
          continue;
        case 6:
          if (tag !== 50) {
            break;
          }

          message.deviceId = reader.string();
          continue;
        case 8:
          if (tag !== 66) {
            break;
          }

          message.debugDeviceIdOverride = reader.string();
          continue;
        case 10:
          if (tag !== 82) {
            break;
          }

          message.carrierGeo = reader.string();
          continue;
        case 11:
          if (tag !== 88) {
            break;
          }

          message.crackedHl = reader.bool();
          continue;
        case 12:
          if (tag !== 98) {
            break;
          }

          message.deviceMake = reader.string();
          continue;
        case 13:
          if (tag !== 106) {
            break;
          }

          message.deviceModel = reader.string();
          continue;
        case 14:
          if (tag !== 114) {
            break;
          }

          message.visitorData = reader.string();
          continue;
        case 15:
          if (tag !== 122) {
            break;
          }

          message.userAgent = reader.string();
          continue;
        case 16:
          if (tag !== 128) {
            break;
          }

          message.clientName = reader.int32();
          continue;
        case 17:
          if (tag !== 138) {
            break;
          }

          message.clientVersion = reader.string();
          continue;
        case 18:
          if (tag !== 146) {
            break;
          }

          message.osName = reader.string();
          continue;
        case 19:
          if (tag !== 154) {
            break;
          }

          message.osVersion = reader.string();
          continue;
        case 20:
          if (tag !== 162) {
            break;
          }

          message.projectId = reader.string();
          continue;
        case 21:
          if (tag !== 170) {
            break;
          }

          message.acceptLanguage = reader.string();
          continue;
        case 22:
          if (tag !== 178) {
            break;
          }

          message.acceptRegion = reader.string();
          continue;
        case 23:
          if (tag !== 186) {
            break;
          }

          message.originalUrl = reader.string();
          continue;
        case 25:
          if (tag !== 202) {
            break;
          }

          message.rawDeviceId = reader.string();
          continue;
        case 27:
          if (tag !== 218) {
            break;
          }

          message.configData = reader.string();
          continue;
        case 31:
          if (tag !== 250) {
            break;
          }

          message.spacecastToken = reader.string();
          continue;
        case 34:
          if (tag !== 274) {
            break;
          }

          message.internalGeo = reader.string();
          continue;
        case 37:
          if (tag !== 296) {
            break;
          }

          message.screenWidthPoints = reader.int32();
          continue;
        case 38:
          if (tag !== 304) {
            break;
          }

          message.screenHeightPoints = reader.int32();
          continue;
        case 39:
          if (tag !== 317) {
            break;
          }

          message.screenWidthInches = reader.float();
          continue;
        case 40:
          if (tag !== 325) {
            break;
          }

          message.screenHeightInches = reader.float();
          continue;
        case 41:
          if (tag !== 328) {
            break;
          }

          message.screenPixelDensity = reader.int32();
          continue;
        case 42:
          if (tag !== 336) {
            break;
          }

          message.platform = reader.int32();
          continue;
        case 45:
          if (tag !== 362) {
            break;
          }

          message.spacecastClientInfo = ClientInfo_SpacecastClientInfo.decode(reader, reader.uint32());
          continue;
        case 46:
          if (tag !== 368) {
            break;
          }

          message.clientFormFactor = reader.int32() as any;
          continue;
        case 48:
          if (tag !== 386) {
            break;
          }

          message.forwardedFor = reader.string();
          continue;
        case 49:
          if (tag !== 394) {
            break;
          }

          message.mobileDataPlanInfo = ClientInfo_MobileDataPlanInfo.decode(reader, reader.uint32());
          continue;
        case 50:
          if (tag !== 400) {
            break;
          }

          message.gmscoreVersionCode = reader.int32();
          continue;
        case 51:
          if (tag !== 408) {
            break;
          }

          message.webpSupport = reader.bool();
          continue;
        case 52:
          if (tag !== 416) {
            break;
          }

          message.cameraType = reader.int32() as any;
          continue;
        case 54:
          if (tag !== 434) {
            break;
          }

          message.experimentsToken = reader.string();
          continue;
        case 55:
          if (tag !== 440) {
            break;
          }

          message.windowWidthPoints = reader.int32();
          continue;
        case 56:
          if (tag !== 448) {
            break;
          }

          message.windowHeightPoints = reader.int32();
          continue;
        case 62:
          if (tag !== 498) {
            break;
          }

          message.configInfo = ClientInfo_ConfigGroupsClientInfo.decode(reader, reader.uint32());
          continue;
        case 63:
          if (tag !== 506) {
            break;
          }

          message.unpluggedLocationInfo = ClientInfo_UnpluggedLocationInfo.decode(reader, reader.uint32());
          continue;
        case 64:
          if (tag !== 512) {
            break;
          }

          message.androidSdkVersion = reader.int32();
          continue;
        case 65:
          if (tag !== 525) {
            break;
          }

          message.screenDensityFloat = reader.float();
          continue;
        case 66:
          if (tag !== 528) {
            break;
          }

          message.firstTimeSignInExperimentIds = reader.int32();
          continue;
        case 67:
          if (tag !== 536) {
            break;
          }

          message.utcOffsetMinutes = reader.int32();
          continue;
        case 68:
          if (tag !== 544) {
            break;
          }

          message.animatedWebpSupport = reader.bool();
          continue;
        case 69:
          if (tag !== 554) {
            break;
          }

          message.kidsAppInfo = ClientInfo_KidsAppInfo.decode(reader, reader.uint32());
          continue;
        case 70:
          if (tag !== 562) {
            break;
          }

          message.musicAppInfo = ClientInfo_MusicAppInfo.decode(reader, reader.uint32());
          continue;
        case 71:
          if (tag !== 570) {
            break;
          }

          message.tvAppInfo = ClientInfo_TvAppInfo.decode(reader, reader.uint32());
          continue;
        case 72:
          if (tag !== 578) {
            break;
          }

          message.internalGeoIp = reader.string();
          continue;
        case 73:
          if (tag !== 586) {
            break;
          }

          message.unpluggedAppInfo = ClientInfo_UnpluggedAppInfo.decode(reader, reader.uint32());
          continue;
        case 74:
          if (tag !== 594) {
            break;
          }

          message.locationInfo = ClientInfo_LocationInfo.decode(reader, reader.uint32());
          continue;
        case 76:
          if (tag !== 610) {
            break;
          }

          message.contentSizeCategory = reader.string();
          continue;
        case 77:
          if (tag !== 621) {
            break;
          }

          message.fontScale = reader.float();
          continue;
        case 78:
          if (tag !== 624) {
            break;
          }

          message.userInterfaceTheme = reader.int32() as any;
          continue;
        case 80:
          if (tag !== 642) {
            break;
          }

          message.timeZone = reader.string();
          continue;
        case 81:
          if (tag !== 650) {
            break;
          }

          message.homeGroupInfo = ClientInfo_HomeGroupInfo.decode(reader, reader.uint32());
          continue;
        case 84:
          if (tag !== 674) {
            break;
          }

          message.emlTemplateContext = reader.bytes();
          continue;
        case 85:
          if (tag !== 682) {
            break;
          }

          message.coldAppBundleConfigData = reader.bytes();
          continue;
        case 87:
          if (tag !== 698) {
            break;
          }

          message.browserName = reader.string();
          continue;
        case 88:
          if (tag !== 706) {
            break;
          }

          message.browserVersion = reader.string();
          continue;
        case 89:
          if (tag !== 714) {
            break;
          }

          message.locationPlayabilityToken = reader.string();
          continue;
        case 92:
          if (tag !== 738) {
            break;
          }

          message.chipset = reader.string();
          continue;
        case 93:
          if (tag !== 746) {
            break;
          }

          message.firmwareVersion = reader.string();
          continue;
        case 95:
          if (tag !== 760) {
            break;
          }

          message.memoryTotalKbytes = longToNumber(reader.int64());
          continue;
        case 96:
          if (tag !== 770) {
            break;
          }

          message.mainAppWebInfo = ClientInfo_MainAppWebInfo.decode(reader, reader.uint32());
          continue;
        case 97:
          if (tag !== 778) {
            break;
          }

          message.notificationPermissionInfo = ClientInfo_NotificationPermissionInfo.decode(reader, reader.uint32());
          continue;
        case 98:
          if (tag !== 786) {
            break;
          }

          message.deviceBrand = reader.string();
          continue;
        case 102:
          if (tag !== 818) {
            break;
          }

          message.glDeviceInfo = ClientInfo_GLDeviceInfo.decode(reader, reader.uint32());
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_MainAppWebInfo(): ClientInfo_MainAppWebInfo {
  return {
    graftUrl: undefined,
    pwaInstallabilityStatus: undefined,
    webDisplayMode: undefined,
    isWebNativeShareAvailable: undefined,
    storeDigitalGoodsApiSupportStatus: undefined,
  };
}

export const ClientInfo_MainAppWebInfo: MessageFns<ClientInfo_MainAppWebInfo> = {
  encode(message: ClientInfo_MainAppWebInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.graftUrl !== undefined) {
      writer.uint32(10).string(message.graftUrl);
    }
    if (message.pwaInstallabilityStatus !== undefined) {
      writer.uint32(16).int32(message.pwaInstallabilityStatus);
    }
    if (message.webDisplayMode !== undefined) {
      writer.uint32(24).int32(message.webDisplayMode);
    }
    if (message.isWebNativeShareAvailable !== undefined) {
      writer.uint32(32).bool(message.isWebNativeShareAvailable);
    }
    if (message.storeDigitalGoodsApiSupportStatus !== undefined) {
      writer.uint32(40).int32(message.storeDigitalGoodsApiSupportStatus);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_MainAppWebInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_MainAppWebInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.graftUrl = reader.string();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.pwaInstallabilityStatus = reader.int32() as any;
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.webDisplayMode = reader.int32() as any;
          continue;
        case 4:
          if (tag !== 32) {
            break;
          }

          message.isWebNativeShareAvailable = reader.bool();
          continue;
        case 5:
          if (tag !== 40) {
            break;
          }

          message.storeDigitalGoodsApiSupportStatus = reader.int32() as any;
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_NotificationPermissionInfo(): ClientInfo_NotificationPermissionInfo {
  return { notificationsSetting: undefined, lastDeviceOptInChangeTimeAgoSec: undefined };
}

export const ClientInfo_NotificationPermissionInfo: MessageFns<ClientInfo_NotificationPermissionInfo> = {
  encode(message: ClientInfo_NotificationPermissionInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.notificationsSetting !== undefined) {
      writer.uint32(8).int32(message.notificationsSetting);
    }
    if (message.lastDeviceOptInChangeTimeAgoSec !== undefined) {
      writer.uint32(16).int64(message.lastDeviceOptInChangeTimeAgoSec);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_NotificationPermissionInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_NotificationPermissionInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.notificationsSetting = reader.int32() as any;
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.lastDeviceOptInChangeTimeAgoSec = longToNumber(reader.int64());
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_GLDeviceInfo(): ClientInfo_GLDeviceInfo {
  return { glRenderer: undefined, glEsVersionMajor: undefined, glEsVersionMinor: undefined };
}

export const ClientInfo_GLDeviceInfo: MessageFns<ClientInfo_GLDeviceInfo> = {
  encode(message: ClientInfo_GLDeviceInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.glRenderer !== undefined) {
      writer.uint32(10).string(message.glRenderer);
    }
    if (message.glEsVersionMajor !== undefined) {
      writer.uint32(16).int32(message.glEsVersionMajor);
    }
    if (message.glEsVersionMinor !== undefined) {
      writer.uint32(24).int32(message.glEsVersionMinor);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_GLDeviceInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_GLDeviceInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.glRenderer = reader.string();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.glEsVersionMajor = reader.int32();
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.glEsVersionMinor = reader.int32();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_SpacecastClientInfo(): ClientInfo_SpacecastClientInfo {
  return { appliances: undefined, interactionLevel: undefined };
}

export const ClientInfo_SpacecastClientInfo: MessageFns<ClientInfo_SpacecastClientInfo> = {
  encode(message: ClientInfo_SpacecastClientInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.appliances !== undefined) {
      ClientInfo_SpacecastClientInfo_SpacecastAppliance.encode(message.appliances, writer.uint32(10).fork()).join();
    }
    if (message.interactionLevel !== undefined) {
      writer.uint32(16).int32(message.interactionLevel);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_SpacecastClientInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_SpacecastClientInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.appliances = ClientInfo_SpacecastClientInfo_SpacecastAppliance.decode(reader, reader.uint32());
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.interactionLevel = reader.int32() as any;
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_SpacecastClientInfo_SpacecastAppliance(): ClientInfo_SpacecastClientInfo_SpacecastAppliance {
  return {
    contentProfileToken: undefined,
    status: undefined,
    hostname: undefined,
    active: undefined,
    deviceId: undefined,
  };
}

export const ClientInfo_SpacecastClientInfo_SpacecastAppliance: MessageFns<
  ClientInfo_SpacecastClientInfo_SpacecastAppliance
> = {
  encode(
    message: ClientInfo_SpacecastClientInfo_SpacecastAppliance,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.contentProfileToken !== undefined) {
      writer.uint32(10).bytes(message.contentProfileToken);
    }
    if (message.status !== undefined) {
      writer.uint32(16).int32(message.status);
    }
    if (message.hostname !== undefined) {
      writer.uint32(26).string(message.hostname);
    }
    if (message.active !== undefined) {
      writer.uint32(32).bool(message.active);
    }
    if (message.deviceId !== undefined) {
      writer.uint32(42).string(message.deviceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_SpacecastClientInfo_SpacecastAppliance {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_SpacecastClientInfo_SpacecastAppliance();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.contentProfileToken = reader.bytes();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.status = reader.int32() as any;
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }

          message.hostname = reader.string();
          continue;
        case 4:
          if (tag !== 32) {
            break;
          }

          message.active = reader.bool();
          continue;
        case 5:
          if (tag !== 42) {
            break;
          }

          message.deviceId = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_MobileDataPlanInfo(): ClientInfo_MobileDataPlanInfo {
  return {
    cpid: undefined,
    serializedDataPlanStatus: undefined,
    dataSavingQualityPickerEnabled: undefined,
    mccmnc: undefined,
  };
}

export const ClientInfo_MobileDataPlanInfo: MessageFns<ClientInfo_MobileDataPlanInfo> = {
  encode(message: ClientInfo_MobileDataPlanInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.cpid !== undefined) {
      writer.uint32(394).string(message.cpid);
    }
    if (message.serializedDataPlanStatus !== undefined) {
      writer.uint32(402).string(message.serializedDataPlanStatus);
    }
    if (message.dataSavingQualityPickerEnabled !== undefined) {
      writer.uint32(416).bool(message.dataSavingQualityPickerEnabled);
    }
    if (message.mccmnc !== undefined) {
      writer.uint32(426).string(message.mccmnc);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_MobileDataPlanInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_MobileDataPlanInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 49:
          if (tag !== 394) {
            break;
          }

          message.cpid = reader.string();
          continue;
        case 50:
          if (tag !== 402) {
            break;
          }

          message.serializedDataPlanStatus = reader.string();
          continue;
        case 52:
          if (tag !== 416) {
            break;
          }

          message.dataSavingQualityPickerEnabled = reader.bool();
          continue;
        case 53:
          if (tag !== 426) {
            break;
          }

          message.mccmnc = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_ConfigGroupsClientInfo(): ClientInfo_ConfigGroupsClientInfo {
  return { coldConfigData: undefined, coldHashData: undefined, hotHashData: undefined, appInstallData: undefined };
}

export const ClientInfo_ConfigGroupsClientInfo: MessageFns<ClientInfo_ConfigGroupsClientInfo> = {
  encode(message: ClientInfo_ConfigGroupsClientInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.coldConfigData !== undefined) {
      writer.uint32(10).string(message.coldConfigData);
    }
    if (message.coldHashData !== undefined) {
      writer.uint32(26).string(message.coldHashData);
    }
    if (message.hotHashData !== undefined) {
      writer.uint32(42).string(message.hotHashData);
    }
    if (message.appInstallData !== undefined) {
      writer.uint32(50).string(message.appInstallData);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_ConfigGroupsClientInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_ConfigGroupsClientInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.coldConfigData = reader.string();
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }

          message.coldHashData = reader.string();
          continue;
        case 5:
          if (tag !== 42) {
            break;
          }

          message.hotHashData = reader.string();
          continue;
        case 6:
          if (tag !== 50) {
            break;
          }

          message.appInstallData = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_UnpluggedLocationInfo(): ClientInfo_UnpluggedLocationInfo {
  return {
    latitudeE7: undefined,
    longitudeE7: undefined,
    localTimestampMs: undefined,
    ipAddress: undefined,
    timezone: undefined,
    prefer24HourTime: undefined,
    locationRadiusMeters: undefined,
    isInitialLoad: undefined,
    browserPermissionGranted: undefined,
    clientPermissionState: undefined,
    locationOverrideToken: undefined,
  };
}

export const ClientInfo_UnpluggedLocationInfo: MessageFns<ClientInfo_UnpluggedLocationInfo> = {
  encode(message: ClientInfo_UnpluggedLocationInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.latitudeE7 !== undefined) {
      writer.uint32(8).int32(message.latitudeE7);
    }
    if (message.longitudeE7 !== undefined) {
      writer.uint32(16).int32(message.longitudeE7);
    }
    if (message.localTimestampMs !== undefined) {
      writer.uint32(24).int64(message.localTimestampMs);
    }
    if (message.ipAddress !== undefined) {
      writer.uint32(34).string(message.ipAddress);
    }
    if (message.timezone !== undefined) {
      writer.uint32(42).string(message.timezone);
    }
    if (message.prefer24HourTime !== undefined) {
      writer.uint32(48).bool(message.prefer24HourTime);
    }
    if (message.locationRadiusMeters !== undefined) {
      writer.uint32(56).int32(message.locationRadiusMeters);
    }
    if (message.isInitialLoad !== undefined) {
      writer.uint32(64).bool(message.isInitialLoad);
    }
    if (message.browserPermissionGranted !== undefined) {
      writer.uint32(72).bool(message.browserPermissionGranted);
    }
    if (message.clientPermissionState !== undefined) {
      writer.uint32(80).int32(message.clientPermissionState);
    }
    if (message.locationOverrideToken !== undefined) {
      writer.uint32(90).string(message.locationOverrideToken);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_UnpluggedLocationInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_UnpluggedLocationInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.latitudeE7 = reader.int32();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.longitudeE7 = reader.int32();
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.localTimestampMs = longToNumber(reader.int64());
          continue;
        case 4:
          if (tag !== 34) {
            break;
          }

          message.ipAddress = reader.string();
          continue;
        case 5:
          if (tag !== 42) {
            break;
          }

          message.timezone = reader.string();
          continue;
        case 6:
          if (tag !== 48) {
            break;
          }

          message.prefer24HourTime = reader.bool();
          continue;
        case 7:
          if (tag !== 56) {
            break;
          }

          message.locationRadiusMeters = reader.int32();
          continue;
        case 8:
          if (tag !== 64) {
            break;
          }

          message.isInitialLoad = reader.bool();
          continue;
        case 9:
          if (tag !== 72) {
            break;
          }

          message.browserPermissionGranted = reader.bool();
          continue;
        case 10:
          if (tag !== 80) {
            break;
          }

          message.clientPermissionState = reader.int32();
          continue;
        case 11:
          if (tag !== 90) {
            break;
          }

          message.locationOverrideToken = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_KidsAppInfo(): ClientInfo_KidsAppInfo {
  return {
    contentSettings: undefined,
    parentCurationMode: undefined,
    categorySettings: undefined,
    userEducationSettings: undefined,
  };
}

export const ClientInfo_KidsAppInfo: MessageFns<ClientInfo_KidsAppInfo> = {
  encode(message: ClientInfo_KidsAppInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.contentSettings !== undefined) {
      ClientInfo_KidsAppInfo_KidsContentSettings.encode(message.contentSettings, writer.uint32(10).fork()).join();
    }
    if (message.parentCurationMode !== undefined) {
      writer.uint32(16).int32(message.parentCurationMode);
    }
    if (message.categorySettings !== undefined) {
      ClientInfo_KidsAppInfo_KidsCategorySettings.encode(message.categorySettings, writer.uint32(26).fork()).join();
    }
    if (message.userEducationSettings !== undefined) {
      ClientInfo_KidsAppInfo_KidsUserEducationSettings.encode(message.userEducationSettings, writer.uint32(34).fork())
        .join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_KidsAppInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_KidsAppInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.contentSettings = ClientInfo_KidsAppInfo_KidsContentSettings.decode(reader, reader.uint32());
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.parentCurationMode = reader.int32() as any;
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }

          message.categorySettings = ClientInfo_KidsAppInfo_KidsCategorySettings.decode(reader, reader.uint32());
          continue;
        case 4:
          if (tag !== 34) {
            break;
          }

          message.userEducationSettings = ClientInfo_KidsAppInfo_KidsUserEducationSettings.decode(
            reader,
            reader.uint32(),
          );
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_KidsAppInfo_KidsContentSettings(): ClientInfo_KidsAppInfo_KidsContentSettings {
  return { kidsNoSearchMode: undefined, ageUpMode: undefined, contentDensity: undefined };
}

export const ClientInfo_KidsAppInfo_KidsContentSettings: MessageFns<ClientInfo_KidsAppInfo_KidsContentSettings> = {
  encode(message: ClientInfo_KidsAppInfo_KidsContentSettings, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.kidsNoSearchMode !== undefined) {
      writer.uint32(8).int32(message.kidsNoSearchMode);
    }
    if (message.ageUpMode !== undefined) {
      writer.uint32(16).int32(message.ageUpMode);
    }
    if (message.contentDensity !== undefined) {
      writer.uint32(24).int32(message.contentDensity);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_KidsAppInfo_KidsContentSettings {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_KidsAppInfo_KidsContentSettings();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.kidsNoSearchMode = reader.int32() as any;
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.ageUpMode = reader.int32() as any;
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.contentDensity = reader.int32() as any;
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_KidsAppInfo_KidsCategorySettings(): ClientInfo_KidsAppInfo_KidsCategorySettings {
  return { enabledCategories: undefined };
}

export const ClientInfo_KidsAppInfo_KidsCategorySettings: MessageFns<ClientInfo_KidsAppInfo_KidsCategorySettings> = {
  encode(
    message: ClientInfo_KidsAppInfo_KidsCategorySettings,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.enabledCategories !== undefined) {
      writer.uint32(10).string(message.enabledCategories);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_KidsAppInfo_KidsCategorySettings {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_KidsAppInfo_KidsCategorySettings();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.enabledCategories = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_KidsAppInfo_KidsUserEducationSettings(): ClientInfo_KidsAppInfo_KidsUserEducationSettings {
  return {
    hasSeenHomeChipBarUserEducation: undefined,
    hasSeenHomePivotBarUserEducation: undefined,
    hasSeenParentMuirUserEducation: undefined,
  };
}

export const ClientInfo_KidsAppInfo_KidsUserEducationSettings: MessageFns<
  ClientInfo_KidsAppInfo_KidsUserEducationSettings
> = {
  encode(
    message: ClientInfo_KidsAppInfo_KidsUserEducationSettings,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.hasSeenHomeChipBarUserEducation !== undefined) {
      writer.uint32(8).bool(message.hasSeenHomeChipBarUserEducation);
    }
    if (message.hasSeenHomePivotBarUserEducation !== undefined) {
      writer.uint32(16).bool(message.hasSeenHomePivotBarUserEducation);
    }
    if (message.hasSeenParentMuirUserEducation !== undefined) {
      writer.uint32(24).bool(message.hasSeenParentMuirUserEducation);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_KidsAppInfo_KidsUserEducationSettings {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_KidsAppInfo_KidsUserEducationSettings();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.hasSeenHomeChipBarUserEducation = reader.bool();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.hasSeenHomePivotBarUserEducation = reader.bool();
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.hasSeenParentMuirUserEducation = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_MusicAppInfo(): ClientInfo_MusicAppInfo {
  return {
    playBackMode: undefined,
    musicLocationMasterSwitch: undefined,
    musicActivityMasterSwitch: undefined,
    offlineMixtapeEnabled: undefined,
    autoOfflineEnabled: undefined,
    iosBackgroundRefreshStatus: undefined,
    smartDownloadsSongLimit: undefined,
    transitionedFromMixtapeToSmartDownloads: undefined,
    pwaInstallabilityStatus: undefined,
    webDisplayMode: undefined,
    musicTier: undefined,
    storeDigitalGoodsApiSupportStatus: undefined,
    smartDownloadsTimeSinceLastOptOutSec: undefined,
  };
}

export const ClientInfo_MusicAppInfo: MessageFns<ClientInfo_MusicAppInfo> = {
  encode(message: ClientInfo_MusicAppInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.playBackMode !== undefined) {
      writer.uint32(8).int32(message.playBackMode);
    }
    if (message.musicLocationMasterSwitch !== undefined) {
      writer.uint32(16).int32(message.musicLocationMasterSwitch);
    }
    if (message.musicActivityMasterSwitch !== undefined) {
      writer.uint32(24).int32(message.musicActivityMasterSwitch);
    }
    if (message.offlineMixtapeEnabled !== undefined) {
      writer.uint32(32).bool(message.offlineMixtapeEnabled);
    }
    if (message.autoOfflineEnabled !== undefined) {
      writer.uint32(40).bool(message.autoOfflineEnabled);
    }
    if (message.iosBackgroundRefreshStatus !== undefined) {
      writer.uint32(48).int32(message.iosBackgroundRefreshStatus);
    }
    if (message.smartDownloadsSongLimit !== undefined) {
      writer.uint32(56).int32(message.smartDownloadsSongLimit);
    }
    if (message.transitionedFromMixtapeToSmartDownloads !== undefined) {
      writer.uint32(64).bool(message.transitionedFromMixtapeToSmartDownloads);
    }
    if (message.pwaInstallabilityStatus !== undefined) {
      writer.uint32(72).int32(message.pwaInstallabilityStatus);
    }
    if (message.webDisplayMode !== undefined) {
      writer.uint32(80).int32(message.webDisplayMode);
    }
    if (message.musicTier !== undefined) {
      writer.uint32(88).int32(message.musicTier);
    }
    if (message.storeDigitalGoodsApiSupportStatus !== undefined) {
      writer.uint32(96).int32(message.storeDigitalGoodsApiSupportStatus);
    }
    if (message.smartDownloadsTimeSinceLastOptOutSec !== undefined) {
      writer.uint32(104).int64(message.smartDownloadsTimeSinceLastOptOutSec);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_MusicAppInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_MusicAppInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.playBackMode = reader.int32() as any;
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.musicLocationMasterSwitch = reader.int32() as any;
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.musicActivityMasterSwitch = reader.int32() as any;
          continue;
        case 4:
          if (tag !== 32) {
            break;
          }

          message.offlineMixtapeEnabled = reader.bool();
          continue;
        case 5:
          if (tag !== 40) {
            break;
          }

          message.autoOfflineEnabled = reader.bool();
          continue;
        case 6:
          if (tag !== 48) {
            break;
          }

          message.iosBackgroundRefreshStatus = reader.int32() as any;
          continue;
        case 7:
          if (tag !== 56) {
            break;
          }

          message.smartDownloadsSongLimit = reader.int32();
          continue;
        case 8:
          if (tag !== 64) {
            break;
          }

          message.transitionedFromMixtapeToSmartDownloads = reader.bool();
          continue;
        case 9:
          if (tag !== 72) {
            break;
          }

          message.pwaInstallabilityStatus = reader.int32() as any;
          continue;
        case 10:
          if (tag !== 80) {
            break;
          }

          message.webDisplayMode = reader.int32() as any;
          continue;
        case 11:
          if (tag !== 88) {
            break;
          }

          message.musicTier = reader.int32() as any;
          continue;
        case 12:
          if (tag !== 96) {
            break;
          }

          message.storeDigitalGoodsApiSupportStatus = reader.int32() as any;
          continue;
        case 13:
          if (tag !== 104) {
            break;
          }

          message.smartDownloadsTimeSinceLastOptOutSec = longToNumber(reader.int64());
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_TvAppInfo(): ClientInfo_TvAppInfo {
  return {
    mdxImpactedSessionsServerEvents: undefined,
    enablePrivacyFilter: undefined,
    zylonLeftNav: undefined,
    certificationScope: undefined,
    livingRoomPoTokenId: undefined,
    jsEngineString: undefined,
    voiceCapability: undefined,
    systemIntegrator: undefined,
    androidBuildFingerprint: undefined,
    cobaltAppVersion: undefined,
    cobaltStarboardVersion: undefined,
    useStartPlaybackPreviewCommand: undefined,
    shouldShowPersistentSigninOnHome: undefined,
    androidPlayServicesVersion: undefined,
  };
}

export const ClientInfo_TvAppInfo: MessageFns<ClientInfo_TvAppInfo> = {
  encode(message: ClientInfo_TvAppInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.mdxImpactedSessionsServerEvents !== undefined) {
      writer.uint32(26).string(message.mdxImpactedSessionsServerEvents);
    }
    if (message.enablePrivacyFilter !== undefined) {
      writer.uint32(48).bool(message.enablePrivacyFilter);
    }
    if (message.zylonLeftNav !== undefined) {
      writer.uint32(56).bool(message.zylonLeftNav);
    }
    if (message.certificationScope !== undefined) {
      writer.uint32(74).string(message.certificationScope);
    }
    if (message.livingRoomPoTokenId !== undefined) {
      writer.uint32(82).string(message.livingRoomPoTokenId);
    }
    if (message.jsEngineString !== undefined) {
      writer.uint32(98).string(message.jsEngineString);
    }
    if (message.voiceCapability !== undefined) {
      ClientInfo_TvAppInfo_VoiceCapability.encode(message.voiceCapability, writer.uint32(106).fork()).join();
    }
    if (message.systemIntegrator !== undefined) {
      writer.uint32(114).string(message.systemIntegrator);
    }
    if (message.androidBuildFingerprint !== undefined) {
      writer.uint32(146).string(message.androidBuildFingerprint);
    }
    if (message.cobaltAppVersion !== undefined) {
      writer.uint32(154).string(message.cobaltAppVersion);
    }
    if (message.cobaltStarboardVersion !== undefined) {
      writer.uint32(162).string(message.cobaltStarboardVersion);
    }
    if (message.useStartPlaybackPreviewCommand !== undefined) {
      writer.uint32(176).bool(message.useStartPlaybackPreviewCommand);
    }
    if (message.shouldShowPersistentSigninOnHome !== undefined) {
      writer.uint32(184).bool(message.shouldShowPersistentSigninOnHome);
    }
    if (message.androidPlayServicesVersion !== undefined) {
      writer.uint32(194).string(message.androidPlayServicesVersion);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_TvAppInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_TvAppInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 3:
          if (tag !== 26) {
            break;
          }

          message.mdxImpactedSessionsServerEvents = reader.string();
          continue;
        case 6:
          if (tag !== 48) {
            break;
          }

          message.enablePrivacyFilter = reader.bool();
          continue;
        case 7:
          if (tag !== 56) {
            break;
          }

          message.zylonLeftNav = reader.bool();
          continue;
        case 9:
          if (tag !== 74) {
            break;
          }

          message.certificationScope = reader.string();
          continue;
        case 10:
          if (tag !== 82) {
            break;
          }

          message.livingRoomPoTokenId = reader.string();
          continue;
        case 12:
          if (tag !== 98) {
            break;
          }

          message.jsEngineString = reader.string();
          continue;
        case 13:
          if (tag !== 106) {
            break;
          }

          message.voiceCapability = ClientInfo_TvAppInfo_VoiceCapability.decode(reader, reader.uint32());
          continue;
        case 14:
          if (tag !== 114) {
            break;
          }

          message.systemIntegrator = reader.string();
          continue;
        case 18:
          if (tag !== 146) {
            break;
          }

          message.androidBuildFingerprint = reader.string();
          continue;
        case 19:
          if (tag !== 154) {
            break;
          }

          message.cobaltAppVersion = reader.string();
          continue;
        case 20:
          if (tag !== 162) {
            break;
          }

          message.cobaltStarboardVersion = reader.string();
          continue;
        case 22:
          if (tag !== 176) {
            break;
          }

          message.useStartPlaybackPreviewCommand = reader.bool();
          continue;
        case 23:
          if (tag !== 184) {
            break;
          }

          message.shouldShowPersistentSigninOnHome = reader.bool();
          continue;
        case 24:
          if (tag !== 194) {
            break;
          }

          message.androidPlayServicesVersion = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_TvAppInfo_VoiceCapability(): ClientInfo_TvAppInfo_VoiceCapability {
  return { hasSoftMicSupport: undefined, hasHardMicSupport: undefined };
}

export const ClientInfo_TvAppInfo_VoiceCapability: MessageFns<ClientInfo_TvAppInfo_VoiceCapability> = {
  encode(message: ClientInfo_TvAppInfo_VoiceCapability, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.hasSoftMicSupport !== undefined) {
      writer.uint32(8).bool(message.hasSoftMicSupport);
    }
    if (message.hasHardMicSupport !== undefined) {
      writer.uint32(16).bool(message.hasHardMicSupport);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_TvAppInfo_VoiceCapability {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_TvAppInfo_VoiceCapability();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.hasSoftMicSupport = reader.bool();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.hasHardMicSupport = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_UnpluggedAppInfo(): ClientInfo_UnpluggedAppInfo {
  return { enableFilterMode: undefined, iosNotificationPermission: undefined, forceEnableEpg3: undefined };
}

export const ClientInfo_UnpluggedAppInfo: MessageFns<ClientInfo_UnpluggedAppInfo> = {
  encode(message: ClientInfo_UnpluggedAppInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.enableFilterMode !== undefined) {
      writer.uint32(16).bool(message.enableFilterMode);
    }
    if (message.iosNotificationPermission !== undefined) {
      writer.uint32(24).bool(message.iosNotificationPermission);
    }
    if (message.forceEnableEpg3 !== undefined) {
      writer.uint32(56).bool(message.forceEnableEpg3);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_UnpluggedAppInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_UnpluggedAppInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 2:
          if (tag !== 16) {
            break;
          }

          message.enableFilterMode = reader.bool();
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.iosNotificationPermission = reader.bool();
          continue;
        case 7:
          if (tag !== 56) {
            break;
          }

          message.forceEnableEpg3 = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_LocationInfo(): ClientInfo_LocationInfo {
  return {
    locationInfoStatus: undefined,
    ulrStatus: undefined,
    latitudeE7: undefined,
    longitudeE7: undefined,
    horizontalAccuracyMeters: undefined,
    locationFreshnessMs: undefined,
    locationPermissionAuthorizationStatus: undefined,
    locationOverrideToken: undefined,
    forceLocationPlayabilityTokenRefresh: undefined,
  };
}

export const ClientInfo_LocationInfo: MessageFns<ClientInfo_LocationInfo> = {
  encode(message: ClientInfo_LocationInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.locationInfoStatus !== undefined) {
      writer.uint32(8).int32(message.locationInfoStatus);
    }
    if (message.ulrStatus !== undefined) {
      ClientInfo_LocationInfo_UrlStatus.encode(message.ulrStatus, writer.uint32(18).fork()).join();
    }
    if (message.latitudeE7 !== undefined) {
      writer.uint32(26).string(message.latitudeE7);
    }
    if (message.longitudeE7 !== undefined) {
      writer.uint32(34).string(message.longitudeE7);
    }
    if (message.horizontalAccuracyMeters !== undefined) {
      writer.uint32(42).string(message.horizontalAccuracyMeters);
    }
    if (message.locationFreshnessMs !== undefined) {
      writer.uint32(50).string(message.locationFreshnessMs);
    }
    if (message.locationPermissionAuthorizationStatus !== undefined) {
      writer.uint32(56).int32(message.locationPermissionAuthorizationStatus);
    }
    if (message.locationOverrideToken !== undefined) {
      writer.uint32(66).string(message.locationOverrideToken);
    }
    if (message.forceLocationPlayabilityTokenRefresh !== undefined) {
      writer.uint32(72).bool(message.forceLocationPlayabilityTokenRefresh);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_LocationInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_LocationInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.locationInfoStatus = reader.int32();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }

          message.ulrStatus = ClientInfo_LocationInfo_UrlStatus.decode(reader, reader.uint32());
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }

          message.latitudeE7 = reader.string();
          continue;
        case 4:
          if (tag !== 34) {
            break;
          }

          message.longitudeE7 = reader.string();
          continue;
        case 5:
          if (tag !== 42) {
            break;
          }

          message.horizontalAccuracyMeters = reader.string();
          continue;
        case 6:
          if (tag !== 50) {
            break;
          }

          message.locationFreshnessMs = reader.string();
          continue;
        case 7:
          if (tag !== 56) {
            break;
          }

          message.locationPermissionAuthorizationStatus = reader.int32();
          continue;
        case 8:
          if (tag !== 66) {
            break;
          }

          message.locationOverrideToken = reader.string();
          continue;
        case 9:
          if (tag !== 72) {
            break;
          }

          message.forceLocationPlayabilityTokenRefresh = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_LocationInfo_UrlStatus(): ClientInfo_LocationInfo_UrlStatus {
  return {
    reportingEnabledSetting: undefined,
    historyEnabledSetting: undefined,
    isAllowed: undefined,
    isActive: undefined,
  };
}

export const ClientInfo_LocationInfo_UrlStatus: MessageFns<ClientInfo_LocationInfo_UrlStatus> = {
  encode(message: ClientInfo_LocationInfo_UrlStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.reportingEnabledSetting !== undefined) {
      writer.uint32(8).int32(message.reportingEnabledSetting);
    }
    if (message.historyEnabledSetting !== undefined) {
      writer.uint32(16).int32(message.historyEnabledSetting);
    }
    if (message.isAllowed !== undefined) {
      writer.uint32(24).bool(message.isAllowed);
    }
    if (message.isActive !== undefined) {
      writer.uint32(32).bool(message.isActive);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_LocationInfo_UrlStatus {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_LocationInfo_UrlStatus();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.reportingEnabledSetting = reader.int32();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }

          message.historyEnabledSetting = reader.int32();
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.isAllowed = reader.bool();
          continue;
        case 4:
          if (tag !== 32) {
            break;
          }

          message.isActive = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseClientInfo_HomeGroupInfo(): ClientInfo_HomeGroupInfo {
  return { isPartOfGroup: undefined, isGroup: undefined };
}

export const ClientInfo_HomeGroupInfo: MessageFns<ClientInfo_HomeGroupInfo> = {
  encode(message: ClientInfo_HomeGroupInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.isPartOfGroup !== undefined) {
      writer.uint32(8).bool(message.isPartOfGroup);
    }
    if (message.isGroup !== undefined) {
      writer.uint32(24).bool(message.isGroup);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientInfo_HomeGroupInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientInfo_HomeGroupInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }

          message.isPartOfGroup = reader.bool();
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }

          message.isGroup = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function longToNumber(int64: { toString(): string }): number {
  const num = globalThis.Number(int64.toString());
  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
  }
  return num;
}

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
}
