From 1ec795765fb01a7466bd931a3fdf83e3bcd48310 Mon Sep 17 00:00:00 2001 From: Rin Date: Mon, 11 Jul 2022 08:22:41 +0100 Subject: [PATCH] The initial commit --- .gitignore | 4 + package.json | 24 + prisma/schema.prisma | 11 + proto_src/message.ts | 4056 ++++++++ proto_src/proto/game.ts | 1133 +++ proto_src/service.ts | 2378 +++++ proto_src/system.ts | 1085 +++ proto_src/wm.ts | 19915 ++++++++++++++++++++++++++++++++++++++ src/index.ts | 5 + tsconfig.json | 9 + yarn.lock | 1205 +++ 11 files changed, 29825 insertions(+) create mode 100644 .gitignore create mode 100644 package.json create mode 100644 prisma/schema.prisma create mode 100644 proto_src/message.ts create mode 100644 proto_src/proto/game.ts create mode 100644 proto_src/service.ts create mode 100644 proto_src/system.ts create mode 100644 proto_src/wm.ts create mode 100644 src/index.ts create mode 100644 tsconfig.json create mode 100644 yarn.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d7d7b4c --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +node_modules/ +proto/ +!proto_src/proto/ +.env \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..abeef0e --- /dev/null +++ b/package.json @@ -0,0 +1,24 @@ +{ + "name": "bayshore", + "version": "1.0.0", + "description": "Wangan Midnight Maximum Tune 6 server implementation", + "main": "dist/index.js", + "repository": "https://github.com/ProjectAsakura/Bayshore", + "author": "Luna and Project Asakura", + "license": "MIT", + "private": false, + "devDependencies": { + "@types/express": "^4.17.13", + "@types/node": "^18.0.3", + "prisma": "^4.0.0", + "protobufjs-cli": "^1.0.0", + "ts-node": "^10.8.2", + "typescript": "^4.7.4" + }, + "dependencies": { + "@prisma/client": "^4.0.0", + "express": "^4.18.1", + "protobufjs": "^7.0.0", + "ts-proto": "^1.117.0" + } +} diff --git a/prisma/schema.prisma b/prisma/schema.prisma new file mode 100644 index 0000000..ca0a0fe --- /dev/null +++ b/prisma/schema.prisma @@ -0,0 +1,11 @@ +// This is your Prisma schema file, +// learn more about it in the docs: https://pris.ly/d/prisma-schema + +generator client { + provider = "prisma-client-js" +} + +datasource db { + provider = "sqlite" + url = "file:./bayshore.db" +} diff --git a/proto_src/message.ts b/proto_src/message.ts new file mode 100644 index 0000000..c1d0a7c --- /dev/null +++ b/proto_src/message.ts @@ -0,0 +1,4056 @@ +/* eslint-disable */ +import { Car, GameFeatureVersion } from "./wm"; +import * as _m0 from "protobufjs/minimal"; + +export const protobufPackage = "wm.protobuf"; + +export interface Course { + episodeId: number; + timeAttackId: number; + extremeId: number; + runAreaId: number; + startRampId: number; + timezoneId: number; + bgmId: number; + autoSelect: boolean; + assistOff: boolean; + playerMax: number; + vsRankList: string; + distBase: number; + distAdd: number; + distBonus: number; + randomSeed: number; +} + +export interface HeartBeat { + frameNumber: number; + pcbSerial: string; + serverComm: number; +} + +export interface DriveCabinetState { + iccardRwState: number; + venderState: number; + ffbState: number; + allnetAttestation: number; + updateAttestation: number; + softwareRevision: number; + downloadState: number; + downloadRevision: number; + downloadProgress: number; + updateRevision: number; + eventMode: number; + eventModeDist: number; + eventMode2on2: number; +} + +export interface BatchSetting { + coinChute: number; + buycardCost: number; + gameCost: number; + continueCost: number; + fullcourseCost: number; + freeplay: number; + winsAndRemains: number; + eventMode: number; + eventModeDist: number; + closeType: number; + closeSun: number; + closeMon: number; + closeTue: number; + closeWed: number; + closeThu: number; + closeFri: number; + closeSat: number; + closeDay: number; + softwareRevision: number; + syncTime: number; + eventModeCount: number; + timeZoneType: number; + timeDayLight: number; + clockOffset: number; + eventModeSerial: string; + eventModeSerialEndAt: number; + eventModeSerialErrorcode: number; + eventMode2on2: number; + wasTournamentScheduleSet: number; +} + +export interface Information { + systemMode: number; + syncId: number; + attractMovieId: number; + attractRankingId: number; + attractRandomSeed: number; +} + +export interface RaceCar { + car: Car | undefined; + rank: number; + vsStarCount: number; + vsConsecutiveWins: number; + vsMedalsRankLevel: number; + wasClearedStoryWhithoutLosing: boolean; + rgRegionMapScore: number[]; +} + +export interface TournamentCar { + name: string; + carId: number; + entryNumber: number; +} + +export interface TournamentCarList { + car00: TournamentCar | undefined; + car01: TournamentCar | undefined; + car02: TournamentCar | undefined; + car03: TournamentCar | undefined; + car04: TournamentCar | undefined; + car05: TournamentCar | undefined; + car06: TournamentCar | undefined; + car07: TournamentCar | undefined; + car08: TournamentCar | undefined; + car09: TournamentCar | undefined; + car10: TournamentCar | undefined; + car11: TournamentCar | undefined; + car12: TournamentCar | undefined; + car13: TournamentCar | undefined; + car14: TournamentCar | undefined; + car15: TournamentCar | undefined; + car16: TournamentCar | undefined; + car17: TournamentCar | undefined; + car18: TournamentCar | undefined; + car19: TournamentCar | undefined; + car20: TournamentCar | undefined; + car21: TournamentCar | undefined; + car22: TournamentCar | undefined; + car23: TournamentCar | undefined; + car24: TournamentCar | undefined; + car25: TournamentCar | undefined; + car26: TournamentCar | undefined; + car27: TournamentCar | undefined; + car28: TournamentCar | undefined; + car29: TournamentCar | undefined; + car30: TournamentCar | undefined; + car31: TournamentCar | undefined; +} + +export interface TournamentRaceData { + raceNumber: number; + roundNumber: number; + gameNumber: number; + player00: number; + player01: number; + player02: number; + player03: number; + result00: number; + result01: number; + result02: number; + result03: number; +} + +export interface TournamentRaceDataList { + raceData00: TournamentRaceData | undefined; + raceData01: TournamentRaceData | undefined; + raceData02: TournamentRaceData | undefined; + raceData03: TournamentRaceData | undefined; + raceData04: TournamentRaceData | undefined; + raceData05: TournamentRaceData | undefined; + raceData06: TournamentRaceData | undefined; + raceData07: TournamentRaceData | undefined; + raceData08: TournamentRaceData | undefined; + raceData09: TournamentRaceData | undefined; + raceData10: TournamentRaceData | undefined; + raceData11: TournamentRaceData | undefined; + raceData12: TournamentRaceData | undefined; + raceData13: TournamentRaceData | undefined; + raceData14: TournamentRaceData | undefined; + raceData15: TournamentRaceData | undefined; + raceData16: TournamentRaceData | undefined; + raceData17: TournamentRaceData | undefined; + raceData18: TournamentRaceData | undefined; + raceData19: TournamentRaceData | undefined; + raceData20: TournamentRaceData | undefined; + raceData21: TournamentRaceData | undefined; + raceData22: TournamentRaceData | undefined; + raceData23: TournamentRaceData | undefined; + raceData24: TournamentRaceData | undefined; + raceData25: TournamentRaceData | undefined; + raceData26: TournamentRaceData | undefined; + raceData27: TournamentRaceData | undefined; + raceData28: TournamentRaceData | undefined; + raceData29: TournamentRaceData | undefined; + raceData30: TournamentRaceData | undefined; + raceData31: TournamentRaceData | undefined; + raceData32: TournamentRaceData | undefined; + raceData33: TournamentRaceData | undefined; + raceData34: TournamentRaceData | undefined; +} + +export interface TournamentResult { + car: Car | undefined; + rank: number; + entryNumber: number; +} + +export interface TournamentResultList { + result00: TournamentResult | undefined; + result01: TournamentResult | undefined; + result02: TournamentResult | undefined; + result03: TournamentResult | undefined; +} + +export interface Tournament { + isEnableTournament: boolean; + isClearTournament: boolean; + isEntryPlayerOnly: boolean; + carList: TournamentCarList | undefined; + raceDataList: TournamentRaceDataList | undefined; + isTournamentOn: boolean; + holdYear: number; + holdMonth: number; + holdDay: number; + entryHour: number; + entryMinute: number; + tournamentStartHour: number; + tournamentStartMinute: number; + competitionNum: number; + participantNum: number; + surviverNumOfFirstRace: number; + nowRound: number; + playingGameNumber: number; + isConfirmTournamentResult: boolean; + isTournamentEntry: boolean; + resultList: TournamentResultList | undefined; + hasCommendationStarted: boolean; + isCommendationRankAppeared: boolean; + isCommendationEnded: boolean; + isNextRank: boolean; + commendationPage: number; + showCommendationAgain: boolean; +} + +export interface Message { + racePacket: Uint8Array; + raceCar: Uint8Array; + course: Course | undefined; + vsOk: number; + heartBeat: HeartBeat | undefined; + batchSettingState: number; + driveCabinetState: DriveCabinetState | undefined; + batchSetting: BatchSetting | undefined; + information: Information | undefined; + featureVersion: GameFeatureVersion | undefined; + tournament: Tournament | undefined; +} + +function createBaseCourse(): Course { + return { + episodeId: 0, + timeAttackId: 0, + extremeId: 0, + runAreaId: 0, + startRampId: 0, + timezoneId: 0, + bgmId: 0, + autoSelect: false, + assistOff: false, + playerMax: 0, + vsRankList: "", + distBase: 0, + distAdd: 0, + distBonus: 0, + randomSeed: 0, + }; +} + +export const Course = { + encode( + message: Course, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.episodeId !== 0) { + writer.uint32(8).sint32(message.episodeId); + } + if (message.timeAttackId !== 0) { + writer.uint32(16).sint32(message.timeAttackId); + } + if (message.extremeId !== 0) { + writer.uint32(24).sint32(message.extremeId); + } + if (message.runAreaId !== 0) { + writer.uint32(32).sint32(message.runAreaId); + } + if (message.startRampId !== 0) { + writer.uint32(40).sint32(message.startRampId); + } + if (message.timezoneId !== 0) { + writer.uint32(48).sint32(message.timezoneId); + } + if (message.bgmId !== 0) { + writer.uint32(56).sint32(message.bgmId); + } + if (message.autoSelect === true) { + writer.uint32(64).bool(message.autoSelect); + } + if (message.assistOff === true) { + writer.uint32(72).bool(message.assistOff); + } + if (message.playerMax !== 0) { + writer.uint32(80).int32(message.playerMax); + } + if (message.vsRankList !== "") { + writer.uint32(90).string(message.vsRankList); + } + if (message.distBase !== 0) { + writer.uint32(101).float(message.distBase); + } + if (message.distAdd !== 0) { + writer.uint32(109).float(message.distAdd); + } + if (message.distBonus !== 0) { + writer.uint32(117).float(message.distBonus); + } + if (message.randomSeed !== 0) { + writer.uint32(120).int32(message.randomSeed); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Course { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCourse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.episodeId = reader.sint32(); + break; + case 2: + message.timeAttackId = reader.sint32(); + break; + case 3: + message.extremeId = reader.sint32(); + break; + case 4: + message.runAreaId = reader.sint32(); + break; + case 5: + message.startRampId = reader.sint32(); + break; + case 6: + message.timezoneId = reader.sint32(); + break; + case 7: + message.bgmId = reader.sint32(); + break; + case 8: + message.autoSelect = reader.bool(); + break; + case 9: + message.assistOff = reader.bool(); + break; + case 10: + message.playerMax = reader.int32(); + break; + case 11: + message.vsRankList = reader.string(); + break; + case 12: + message.distBase = reader.float(); + break; + case 13: + message.distAdd = reader.float(); + break; + case 14: + message.distBonus = reader.float(); + break; + case 15: + message.randomSeed = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Course { + return { + episodeId: isSet(object.episodeId) ? Number(object.episodeId) : 0, + timeAttackId: isSet(object.timeAttackId) + ? Number(object.timeAttackId) + : 0, + extremeId: isSet(object.extremeId) ? Number(object.extremeId) : 0, + runAreaId: isSet(object.runAreaId) ? Number(object.runAreaId) : 0, + startRampId: isSet(object.startRampId) ? Number(object.startRampId) : 0, + timezoneId: isSet(object.timezoneId) ? Number(object.timezoneId) : 0, + bgmId: isSet(object.bgmId) ? Number(object.bgmId) : 0, + autoSelect: isSet(object.autoSelect) ? Boolean(object.autoSelect) : false, + assistOff: isSet(object.assistOff) ? Boolean(object.assistOff) : false, + playerMax: isSet(object.playerMax) ? Number(object.playerMax) : 0, + vsRankList: isSet(object.vsRankList) ? String(object.vsRankList) : "", + distBase: isSet(object.distBase) ? Number(object.distBase) : 0, + distAdd: isSet(object.distAdd) ? Number(object.distAdd) : 0, + distBonus: isSet(object.distBonus) ? Number(object.distBonus) : 0, + randomSeed: isSet(object.randomSeed) ? Number(object.randomSeed) : 0, + }; + }, + + toJSON(message: Course): unknown { + const obj: any = {}; + message.episodeId !== undefined && + (obj.episodeId = Math.round(message.episodeId)); + message.timeAttackId !== undefined && + (obj.timeAttackId = Math.round(message.timeAttackId)); + message.extremeId !== undefined && + (obj.extremeId = Math.round(message.extremeId)); + message.runAreaId !== undefined && + (obj.runAreaId = Math.round(message.runAreaId)); + message.startRampId !== undefined && + (obj.startRampId = Math.round(message.startRampId)); + message.timezoneId !== undefined && + (obj.timezoneId = Math.round(message.timezoneId)); + message.bgmId !== undefined && (obj.bgmId = Math.round(message.bgmId)); + message.autoSelect !== undefined && (obj.autoSelect = message.autoSelect); + message.assistOff !== undefined && (obj.assistOff = message.assistOff); + message.playerMax !== undefined && + (obj.playerMax = Math.round(message.playerMax)); + message.vsRankList !== undefined && (obj.vsRankList = message.vsRankList); + message.distBase !== undefined && (obj.distBase = message.distBase); + message.distAdd !== undefined && (obj.distAdd = message.distAdd); + message.distBonus !== undefined && (obj.distBonus = message.distBonus); + message.randomSeed !== undefined && + (obj.randomSeed = Math.round(message.randomSeed)); + return obj; + }, + + fromPartial, I>>(object: I): Course { + const message = createBaseCourse(); + message.episodeId = object.episodeId ?? 0; + message.timeAttackId = object.timeAttackId ?? 0; + message.extremeId = object.extremeId ?? 0; + message.runAreaId = object.runAreaId ?? 0; + message.startRampId = object.startRampId ?? 0; + message.timezoneId = object.timezoneId ?? 0; + message.bgmId = object.bgmId ?? 0; + message.autoSelect = object.autoSelect ?? false; + message.assistOff = object.assistOff ?? false; + message.playerMax = object.playerMax ?? 0; + message.vsRankList = object.vsRankList ?? ""; + message.distBase = object.distBase ?? 0; + message.distAdd = object.distAdd ?? 0; + message.distBonus = object.distBonus ?? 0; + message.randomSeed = object.randomSeed ?? 0; + return message; + }, +}; + +function createBaseHeartBeat(): HeartBeat { + return { frameNumber: 0, pcbSerial: "", serverComm: 0 }; +} + +export const HeartBeat = { + encode( + message: HeartBeat, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.frameNumber !== 0) { + writer.uint32(8).uint32(message.frameNumber); + } + if (message.pcbSerial !== "") { + writer.uint32(18).string(message.pcbSerial); + } + if (message.serverComm !== 0) { + writer.uint32(24).int32(message.serverComm); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): HeartBeat { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseHeartBeat(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.frameNumber = reader.uint32(); + break; + case 2: + message.pcbSerial = reader.string(); + break; + case 3: + message.serverComm = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): HeartBeat { + return { + frameNumber: isSet(object.frameNumber) ? Number(object.frameNumber) : 0, + pcbSerial: isSet(object.pcbSerial) ? String(object.pcbSerial) : "", + serverComm: isSet(object.serverComm) ? Number(object.serverComm) : 0, + }; + }, + + toJSON(message: HeartBeat): unknown { + const obj: any = {}; + message.frameNumber !== undefined && + (obj.frameNumber = Math.round(message.frameNumber)); + message.pcbSerial !== undefined && (obj.pcbSerial = message.pcbSerial); + message.serverComm !== undefined && + (obj.serverComm = Math.round(message.serverComm)); + return obj; + }, + + fromPartial, I>>( + object: I + ): HeartBeat { + const message = createBaseHeartBeat(); + message.frameNumber = object.frameNumber ?? 0; + message.pcbSerial = object.pcbSerial ?? ""; + message.serverComm = object.serverComm ?? 0; + return message; + }, +}; + +function createBaseDriveCabinetState(): DriveCabinetState { + return { + iccardRwState: 0, + venderState: 0, + ffbState: 0, + allnetAttestation: 0, + updateAttestation: 0, + softwareRevision: 0, + downloadState: 0, + downloadRevision: 0, + downloadProgress: 0, + updateRevision: 0, + eventMode: 0, + eventModeDist: 0, + eventMode2on2: 0, + }; +} + +export const DriveCabinetState = { + encode( + message: DriveCabinetState, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.iccardRwState !== 0) { + writer.uint32(8).int32(message.iccardRwState); + } + if (message.venderState !== 0) { + writer.uint32(16).int32(message.venderState); + } + if (message.ffbState !== 0) { + writer.uint32(24).int32(message.ffbState); + } + if (message.allnetAttestation !== 0) { + writer.uint32(32).int32(message.allnetAttestation); + } + if (message.updateAttestation !== 0) { + writer.uint32(40).int32(message.updateAttestation); + } + if (message.softwareRevision !== 0) { + writer.uint32(48).int32(message.softwareRevision); + } + if (message.downloadState !== 0) { + writer.uint32(56).int32(message.downloadState); + } + if (message.downloadRevision !== 0) { + writer.uint32(64).int32(message.downloadRevision); + } + if (message.downloadProgress !== 0) { + writer.uint32(72).int32(message.downloadProgress); + } + if (message.updateRevision !== 0) { + writer.uint32(80).int32(message.updateRevision); + } + if (message.eventMode !== 0) { + writer.uint32(88).int32(message.eventMode); + } + if (message.eventModeDist !== 0) { + writer.uint32(96).int32(message.eventModeDist); + } + if (message.eventMode2on2 !== 0) { + writer.uint32(104).int32(message.eventMode2on2); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): DriveCabinetState { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDriveCabinetState(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.iccardRwState = reader.int32(); + break; + case 2: + message.venderState = reader.int32(); + break; + case 3: + message.ffbState = reader.int32(); + break; + case 4: + message.allnetAttestation = reader.int32(); + break; + case 5: + message.updateAttestation = reader.int32(); + break; + case 6: + message.softwareRevision = reader.int32(); + break; + case 7: + message.downloadState = reader.int32(); + break; + case 8: + message.downloadRevision = reader.int32(); + break; + case 9: + message.downloadProgress = reader.int32(); + break; + case 10: + message.updateRevision = reader.int32(); + break; + case 11: + message.eventMode = reader.int32(); + break; + case 12: + message.eventModeDist = reader.int32(); + break; + case 13: + message.eventMode2on2 = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): DriveCabinetState { + return { + iccardRwState: isSet(object.iccardRwState) + ? Number(object.iccardRwState) + : 0, + venderState: isSet(object.venderState) ? Number(object.venderState) : 0, + ffbState: isSet(object.ffbState) ? Number(object.ffbState) : 0, + allnetAttestation: isSet(object.allnetAttestation) + ? Number(object.allnetAttestation) + : 0, + updateAttestation: isSet(object.updateAttestation) + ? Number(object.updateAttestation) + : 0, + softwareRevision: isSet(object.softwareRevision) + ? Number(object.softwareRevision) + : 0, + downloadState: isSet(object.downloadState) + ? Number(object.downloadState) + : 0, + downloadRevision: isSet(object.downloadRevision) + ? Number(object.downloadRevision) + : 0, + downloadProgress: isSet(object.downloadProgress) + ? Number(object.downloadProgress) + : 0, + updateRevision: isSet(object.updateRevision) + ? Number(object.updateRevision) + : 0, + eventMode: isSet(object.eventMode) ? Number(object.eventMode) : 0, + eventModeDist: isSet(object.eventModeDist) + ? Number(object.eventModeDist) + : 0, + eventMode2on2: isSet(object.eventMode2on2) + ? Number(object.eventMode2on2) + : 0, + }; + }, + + toJSON(message: DriveCabinetState): unknown { + const obj: any = {}; + message.iccardRwState !== undefined && + (obj.iccardRwState = Math.round(message.iccardRwState)); + message.venderState !== undefined && + (obj.venderState = Math.round(message.venderState)); + message.ffbState !== undefined && + (obj.ffbState = Math.round(message.ffbState)); + message.allnetAttestation !== undefined && + (obj.allnetAttestation = Math.round(message.allnetAttestation)); + message.updateAttestation !== undefined && + (obj.updateAttestation = Math.round(message.updateAttestation)); + message.softwareRevision !== undefined && + (obj.softwareRevision = Math.round(message.softwareRevision)); + message.downloadState !== undefined && + (obj.downloadState = Math.round(message.downloadState)); + message.downloadRevision !== undefined && + (obj.downloadRevision = Math.round(message.downloadRevision)); + message.downloadProgress !== undefined && + (obj.downloadProgress = Math.round(message.downloadProgress)); + message.updateRevision !== undefined && + (obj.updateRevision = Math.round(message.updateRevision)); + message.eventMode !== undefined && + (obj.eventMode = Math.round(message.eventMode)); + message.eventModeDist !== undefined && + (obj.eventModeDist = Math.round(message.eventModeDist)); + message.eventMode2on2 !== undefined && + (obj.eventMode2on2 = Math.round(message.eventMode2on2)); + return obj; + }, + + fromPartial, I>>( + object: I + ): DriveCabinetState { + const message = createBaseDriveCabinetState(); + message.iccardRwState = object.iccardRwState ?? 0; + message.venderState = object.venderState ?? 0; + message.ffbState = object.ffbState ?? 0; + message.allnetAttestation = object.allnetAttestation ?? 0; + message.updateAttestation = object.updateAttestation ?? 0; + message.softwareRevision = object.softwareRevision ?? 0; + message.downloadState = object.downloadState ?? 0; + message.downloadRevision = object.downloadRevision ?? 0; + message.downloadProgress = object.downloadProgress ?? 0; + message.updateRevision = object.updateRevision ?? 0; + message.eventMode = object.eventMode ?? 0; + message.eventModeDist = object.eventModeDist ?? 0; + message.eventMode2on2 = object.eventMode2on2 ?? 0; + return message; + }, +}; + +function createBaseBatchSetting(): BatchSetting { + return { + coinChute: 0, + buycardCost: 0, + gameCost: 0, + continueCost: 0, + fullcourseCost: 0, + freeplay: 0, + winsAndRemains: 0, + eventMode: 0, + eventModeDist: 0, + closeType: 0, + closeSun: 0, + closeMon: 0, + closeTue: 0, + closeWed: 0, + closeThu: 0, + closeFri: 0, + closeSat: 0, + closeDay: 0, + softwareRevision: 0, + syncTime: 0, + eventModeCount: 0, + timeZoneType: 0, + timeDayLight: 0, + clockOffset: 0, + eventModeSerial: "", + eventModeSerialEndAt: 0, + eventModeSerialErrorcode: 0, + eventMode2on2: 0, + wasTournamentScheduleSet: 0, + }; +} + +export const BatchSetting = { + encode( + message: BatchSetting, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.coinChute !== 0) { + writer.uint32(8).int32(message.coinChute); + } + if (message.buycardCost !== 0) { + writer.uint32(16).int32(message.buycardCost); + } + if (message.gameCost !== 0) { + writer.uint32(24).int32(message.gameCost); + } + if (message.continueCost !== 0) { + writer.uint32(32).int32(message.continueCost); + } + if (message.fullcourseCost !== 0) { + writer.uint32(40).int32(message.fullcourseCost); + } + if (message.freeplay !== 0) { + writer.uint32(48).int32(message.freeplay); + } + if (message.winsAndRemains !== 0) { + writer.uint32(56).int32(message.winsAndRemains); + } + if (message.eventMode !== 0) { + writer.uint32(64).int32(message.eventMode); + } + if (message.eventModeDist !== 0) { + writer.uint32(72).int32(message.eventModeDist); + } + if (message.closeType !== 0) { + writer.uint32(80).int32(message.closeType); + } + if (message.closeSun !== 0) { + writer.uint32(88).int32(message.closeSun); + } + if (message.closeMon !== 0) { + writer.uint32(96).int32(message.closeMon); + } + if (message.closeTue !== 0) { + writer.uint32(104).int32(message.closeTue); + } + if (message.closeWed !== 0) { + writer.uint32(112).int32(message.closeWed); + } + if (message.closeThu !== 0) { + writer.uint32(120).int32(message.closeThu); + } + if (message.closeFri !== 0) { + writer.uint32(128).int32(message.closeFri); + } + if (message.closeSat !== 0) { + writer.uint32(136).int32(message.closeSat); + } + if (message.closeDay !== 0) { + writer.uint32(144).int32(message.closeDay); + } + if (message.softwareRevision !== 0) { + writer.uint32(152).int32(message.softwareRevision); + } + if (message.syncTime !== 0) { + writer.uint32(160).int32(message.syncTime); + } + if (message.eventModeCount !== 0) { + writer.uint32(168).int32(message.eventModeCount); + } + if (message.timeZoneType !== 0) { + writer.uint32(176).uint32(message.timeZoneType); + } + if (message.timeDayLight !== 0) { + writer.uint32(184).uint32(message.timeDayLight); + } + if (message.clockOffset !== 0) { + writer.uint32(192).int32(message.clockOffset); + } + if (message.eventModeSerial !== "") { + writer.uint32(202).string(message.eventModeSerial); + } + if (message.eventModeSerialEndAt !== 0) { + writer.uint32(208).uint32(message.eventModeSerialEndAt); + } + if (message.eventModeSerialErrorcode !== 0) { + writer.uint32(216).int32(message.eventModeSerialErrorcode); + } + if (message.eventMode2on2 !== 0) { + writer.uint32(224).int32(message.eventMode2on2); + } + if (message.wasTournamentScheduleSet !== 0) { + writer.uint32(232).int32(message.wasTournamentScheduleSet); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): BatchSetting { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBatchSetting(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.coinChute = reader.int32(); + break; + case 2: + message.buycardCost = reader.int32(); + break; + case 3: + message.gameCost = reader.int32(); + break; + case 4: + message.continueCost = reader.int32(); + break; + case 5: + message.fullcourseCost = reader.int32(); + break; + case 6: + message.freeplay = reader.int32(); + break; + case 7: + message.winsAndRemains = reader.int32(); + break; + case 8: + message.eventMode = reader.int32(); + break; + case 9: + message.eventModeDist = reader.int32(); + break; + case 10: + message.closeType = reader.int32(); + break; + case 11: + message.closeSun = reader.int32(); + break; + case 12: + message.closeMon = reader.int32(); + break; + case 13: + message.closeTue = reader.int32(); + break; + case 14: + message.closeWed = reader.int32(); + break; + case 15: + message.closeThu = reader.int32(); + break; + case 16: + message.closeFri = reader.int32(); + break; + case 17: + message.closeSat = reader.int32(); + break; + case 18: + message.closeDay = reader.int32(); + break; + case 19: + message.softwareRevision = reader.int32(); + break; + case 20: + message.syncTime = reader.int32(); + break; + case 21: + message.eventModeCount = reader.int32(); + break; + case 22: + message.timeZoneType = reader.uint32(); + break; + case 23: + message.timeDayLight = reader.uint32(); + break; + case 24: + message.clockOffset = reader.int32(); + break; + case 25: + message.eventModeSerial = reader.string(); + break; + case 26: + message.eventModeSerialEndAt = reader.uint32(); + break; + case 27: + message.eventModeSerialErrorcode = reader.int32(); + break; + case 28: + message.eventMode2on2 = reader.int32(); + break; + case 29: + message.wasTournamentScheduleSet = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): BatchSetting { + return { + coinChute: isSet(object.coinChute) ? Number(object.coinChute) : 0, + buycardCost: isSet(object.buycardCost) ? Number(object.buycardCost) : 0, + gameCost: isSet(object.gameCost) ? Number(object.gameCost) : 0, + continueCost: isSet(object.continueCost) + ? Number(object.continueCost) + : 0, + fullcourseCost: isSet(object.fullcourseCost) + ? Number(object.fullcourseCost) + : 0, + freeplay: isSet(object.freeplay) ? Number(object.freeplay) : 0, + winsAndRemains: isSet(object.winsAndRemains) + ? Number(object.winsAndRemains) + : 0, + eventMode: isSet(object.eventMode) ? Number(object.eventMode) : 0, + eventModeDist: isSet(object.eventModeDist) + ? Number(object.eventModeDist) + : 0, + closeType: isSet(object.closeType) ? Number(object.closeType) : 0, + closeSun: isSet(object.closeSun) ? Number(object.closeSun) : 0, + closeMon: isSet(object.closeMon) ? Number(object.closeMon) : 0, + closeTue: isSet(object.closeTue) ? Number(object.closeTue) : 0, + closeWed: isSet(object.closeWed) ? Number(object.closeWed) : 0, + closeThu: isSet(object.closeThu) ? Number(object.closeThu) : 0, + closeFri: isSet(object.closeFri) ? Number(object.closeFri) : 0, + closeSat: isSet(object.closeSat) ? Number(object.closeSat) : 0, + closeDay: isSet(object.closeDay) ? Number(object.closeDay) : 0, + softwareRevision: isSet(object.softwareRevision) + ? Number(object.softwareRevision) + : 0, + syncTime: isSet(object.syncTime) ? Number(object.syncTime) : 0, + eventModeCount: isSet(object.eventModeCount) + ? Number(object.eventModeCount) + : 0, + timeZoneType: isSet(object.timeZoneType) + ? Number(object.timeZoneType) + : 0, + timeDayLight: isSet(object.timeDayLight) + ? Number(object.timeDayLight) + : 0, + clockOffset: isSet(object.clockOffset) ? Number(object.clockOffset) : 0, + eventModeSerial: isSet(object.eventModeSerial) + ? String(object.eventModeSerial) + : "", + eventModeSerialEndAt: isSet(object.eventModeSerialEndAt) + ? Number(object.eventModeSerialEndAt) + : 0, + eventModeSerialErrorcode: isSet(object.eventModeSerialErrorcode) + ? Number(object.eventModeSerialErrorcode) + : 0, + eventMode2on2: isSet(object.eventMode2on2) + ? Number(object.eventMode2on2) + : 0, + wasTournamentScheduleSet: isSet(object.wasTournamentScheduleSet) + ? Number(object.wasTournamentScheduleSet) + : 0, + }; + }, + + toJSON(message: BatchSetting): unknown { + const obj: any = {}; + message.coinChute !== undefined && + (obj.coinChute = Math.round(message.coinChute)); + message.buycardCost !== undefined && + (obj.buycardCost = Math.round(message.buycardCost)); + message.gameCost !== undefined && + (obj.gameCost = Math.round(message.gameCost)); + message.continueCost !== undefined && + (obj.continueCost = Math.round(message.continueCost)); + message.fullcourseCost !== undefined && + (obj.fullcourseCost = Math.round(message.fullcourseCost)); + message.freeplay !== undefined && + (obj.freeplay = Math.round(message.freeplay)); + message.winsAndRemains !== undefined && + (obj.winsAndRemains = Math.round(message.winsAndRemains)); + message.eventMode !== undefined && + (obj.eventMode = Math.round(message.eventMode)); + message.eventModeDist !== undefined && + (obj.eventModeDist = Math.round(message.eventModeDist)); + message.closeType !== undefined && + (obj.closeType = Math.round(message.closeType)); + message.closeSun !== undefined && + (obj.closeSun = Math.round(message.closeSun)); + message.closeMon !== undefined && + (obj.closeMon = Math.round(message.closeMon)); + message.closeTue !== undefined && + (obj.closeTue = Math.round(message.closeTue)); + message.closeWed !== undefined && + (obj.closeWed = Math.round(message.closeWed)); + message.closeThu !== undefined && + (obj.closeThu = Math.round(message.closeThu)); + message.closeFri !== undefined && + (obj.closeFri = Math.round(message.closeFri)); + message.closeSat !== undefined && + (obj.closeSat = Math.round(message.closeSat)); + message.closeDay !== undefined && + (obj.closeDay = Math.round(message.closeDay)); + message.softwareRevision !== undefined && + (obj.softwareRevision = Math.round(message.softwareRevision)); + message.syncTime !== undefined && + (obj.syncTime = Math.round(message.syncTime)); + message.eventModeCount !== undefined && + (obj.eventModeCount = Math.round(message.eventModeCount)); + message.timeZoneType !== undefined && + (obj.timeZoneType = Math.round(message.timeZoneType)); + message.timeDayLight !== undefined && + (obj.timeDayLight = Math.round(message.timeDayLight)); + message.clockOffset !== undefined && + (obj.clockOffset = Math.round(message.clockOffset)); + message.eventModeSerial !== undefined && + (obj.eventModeSerial = message.eventModeSerial); + message.eventModeSerialEndAt !== undefined && + (obj.eventModeSerialEndAt = Math.round(message.eventModeSerialEndAt)); + message.eventModeSerialErrorcode !== undefined && + (obj.eventModeSerialErrorcode = Math.round( + message.eventModeSerialErrorcode + )); + message.eventMode2on2 !== undefined && + (obj.eventMode2on2 = Math.round(message.eventMode2on2)); + message.wasTournamentScheduleSet !== undefined && + (obj.wasTournamentScheduleSet = Math.round( + message.wasTournamentScheduleSet + )); + return obj; + }, + + fromPartial, I>>( + object: I + ): BatchSetting { + const message = createBaseBatchSetting(); + message.coinChute = object.coinChute ?? 0; + message.buycardCost = object.buycardCost ?? 0; + message.gameCost = object.gameCost ?? 0; + message.continueCost = object.continueCost ?? 0; + message.fullcourseCost = object.fullcourseCost ?? 0; + message.freeplay = object.freeplay ?? 0; + message.winsAndRemains = object.winsAndRemains ?? 0; + message.eventMode = object.eventMode ?? 0; + message.eventModeDist = object.eventModeDist ?? 0; + message.closeType = object.closeType ?? 0; + message.closeSun = object.closeSun ?? 0; + message.closeMon = object.closeMon ?? 0; + message.closeTue = object.closeTue ?? 0; + message.closeWed = object.closeWed ?? 0; + message.closeThu = object.closeThu ?? 0; + message.closeFri = object.closeFri ?? 0; + message.closeSat = object.closeSat ?? 0; + message.closeDay = object.closeDay ?? 0; + message.softwareRevision = object.softwareRevision ?? 0; + message.syncTime = object.syncTime ?? 0; + message.eventModeCount = object.eventModeCount ?? 0; + message.timeZoneType = object.timeZoneType ?? 0; + message.timeDayLight = object.timeDayLight ?? 0; + message.clockOffset = object.clockOffset ?? 0; + message.eventModeSerial = object.eventModeSerial ?? ""; + message.eventModeSerialEndAt = object.eventModeSerialEndAt ?? 0; + message.eventModeSerialErrorcode = object.eventModeSerialErrorcode ?? 0; + message.eventMode2on2 = object.eventMode2on2 ?? 0; + message.wasTournamentScheduleSet = object.wasTournamentScheduleSet ?? 0; + return message; + }, +}; + +function createBaseInformation(): Information { + return { + systemMode: 0, + syncId: 0, + attractMovieId: 0, + attractRankingId: 0, + attractRandomSeed: 0, + }; +} + +export const Information = { + encode( + message: Information, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.systemMode !== 0) { + writer.uint32(8).uint32(message.systemMode); + } + if (message.syncId !== 0) { + writer.uint32(16).sint32(message.syncId); + } + if (message.attractMovieId !== 0) { + writer.uint32(24).sint32(message.attractMovieId); + } + if (message.attractRankingId !== 0) { + writer.uint32(32).sint32(message.attractRankingId); + } + if (message.attractRandomSeed !== 0) { + writer.uint32(40).int32(message.attractRandomSeed); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Information { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInformation(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.systemMode = reader.uint32(); + break; + case 2: + message.syncId = reader.sint32(); + break; + case 3: + message.attractMovieId = reader.sint32(); + break; + case 4: + message.attractRankingId = reader.sint32(); + break; + case 5: + message.attractRandomSeed = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Information { + return { + systemMode: isSet(object.systemMode) ? Number(object.systemMode) : 0, + syncId: isSet(object.syncId) ? Number(object.syncId) : 0, + attractMovieId: isSet(object.attractMovieId) + ? Number(object.attractMovieId) + : 0, + attractRankingId: isSet(object.attractRankingId) + ? Number(object.attractRankingId) + : 0, + attractRandomSeed: isSet(object.attractRandomSeed) + ? Number(object.attractRandomSeed) + : 0, + }; + }, + + toJSON(message: Information): unknown { + const obj: any = {}; + message.systemMode !== undefined && + (obj.systemMode = Math.round(message.systemMode)); + message.syncId !== undefined && (obj.syncId = Math.round(message.syncId)); + message.attractMovieId !== undefined && + (obj.attractMovieId = Math.round(message.attractMovieId)); + message.attractRankingId !== undefined && + (obj.attractRankingId = Math.round(message.attractRankingId)); + message.attractRandomSeed !== undefined && + (obj.attractRandomSeed = Math.round(message.attractRandomSeed)); + return obj; + }, + + fromPartial, I>>( + object: I + ): Information { + const message = createBaseInformation(); + message.systemMode = object.systemMode ?? 0; + message.syncId = object.syncId ?? 0; + message.attractMovieId = object.attractMovieId ?? 0; + message.attractRankingId = object.attractRankingId ?? 0; + message.attractRandomSeed = object.attractRandomSeed ?? 0; + return message; + }, +}; + +function createBaseRaceCar(): RaceCar { + return { + car: undefined, + rank: 0, + vsStarCount: 0, + vsConsecutiveWins: 0, + vsMedalsRankLevel: 0, + wasClearedStoryWhithoutLosing: false, + rgRegionMapScore: [], + }; +} + +export const RaceCar = { + encode( + message: RaceCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.rank !== 0) { + writer.uint32(16).uint32(message.rank); + } + if (message.vsStarCount !== 0) { + writer.uint32(24).uint32(message.vsStarCount); + } + if (message.vsConsecutiveWins !== 0) { + writer.uint32(32).uint32(message.vsConsecutiveWins); + } + if (message.vsMedalsRankLevel !== 0) { + writer.uint32(40).uint32(message.vsMedalsRankLevel); + } + if (message.wasClearedStoryWhithoutLosing === true) { + writer.uint32(48).bool(message.wasClearedStoryWhithoutLosing); + } + writer.uint32(58).fork(); + for (const v of message.rgRegionMapScore) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): RaceCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRaceCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.rank = reader.uint32(); + break; + case 3: + message.vsStarCount = reader.uint32(); + break; + case 4: + message.vsConsecutiveWins = reader.uint32(); + break; + case 5: + message.vsMedalsRankLevel = reader.uint32(); + break; + case 6: + message.wasClearedStoryWhithoutLosing = reader.bool(); + break; + case 7: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.rgRegionMapScore.push(reader.uint32()); + } + } else { + message.rgRegionMapScore.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RaceCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + rank: isSet(object.rank) ? Number(object.rank) : 0, + vsStarCount: isSet(object.vsStarCount) ? Number(object.vsStarCount) : 0, + vsConsecutiveWins: isSet(object.vsConsecutiveWins) + ? Number(object.vsConsecutiveWins) + : 0, + vsMedalsRankLevel: isSet(object.vsMedalsRankLevel) + ? Number(object.vsMedalsRankLevel) + : 0, + wasClearedStoryWhithoutLosing: isSet(object.wasClearedStoryWhithoutLosing) + ? Boolean(object.wasClearedStoryWhithoutLosing) + : false, + rgRegionMapScore: Array.isArray(object?.rgRegionMapScore) + ? object.rgRegionMapScore.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: RaceCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.rank !== undefined && (obj.rank = Math.round(message.rank)); + message.vsStarCount !== undefined && + (obj.vsStarCount = Math.round(message.vsStarCount)); + message.vsConsecutiveWins !== undefined && + (obj.vsConsecutiveWins = Math.round(message.vsConsecutiveWins)); + message.vsMedalsRankLevel !== undefined && + (obj.vsMedalsRankLevel = Math.round(message.vsMedalsRankLevel)); + message.wasClearedStoryWhithoutLosing !== undefined && + (obj.wasClearedStoryWhithoutLosing = + message.wasClearedStoryWhithoutLosing); + if (message.rgRegionMapScore) { + obj.rgRegionMapScore = message.rgRegionMapScore.map((e) => Math.round(e)); + } else { + obj.rgRegionMapScore = []; + } + return obj; + }, + + fromPartial, I>>(object: I): RaceCar { + const message = createBaseRaceCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.rank = object.rank ?? 0; + message.vsStarCount = object.vsStarCount ?? 0; + message.vsConsecutiveWins = object.vsConsecutiveWins ?? 0; + message.vsMedalsRankLevel = object.vsMedalsRankLevel ?? 0; + message.wasClearedStoryWhithoutLosing = + object.wasClearedStoryWhithoutLosing ?? false; + message.rgRegionMapScore = object.rgRegionMapScore?.map((e) => e) || []; + return message; + }, +}; + +function createBaseTournamentCar(): TournamentCar { + return { name: "", carId: 0, entryNumber: 0 }; +} + +export const TournamentCar = { + encode( + message: TournamentCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.carId !== 0) { + writer.uint32(16).sint32(message.carId); + } + if (message.entryNumber !== 0) { + writer.uint32(24).sint32(message.entryNumber); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): TournamentCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournamentCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.carId = reader.sint32(); + break; + case 3: + message.entryNumber = reader.sint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TournamentCar { + return { + name: isSet(object.name) ? String(object.name) : "", + carId: isSet(object.carId) ? Number(object.carId) : 0, + entryNumber: isSet(object.entryNumber) ? Number(object.entryNumber) : 0, + }; + }, + + toJSON(message: TournamentCar): unknown { + const obj: any = {}; + message.name !== undefined && (obj.name = message.name); + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.entryNumber !== undefined && + (obj.entryNumber = Math.round(message.entryNumber)); + return obj; + }, + + fromPartial, I>>( + object: I + ): TournamentCar { + const message = createBaseTournamentCar(); + message.name = object.name ?? ""; + message.carId = object.carId ?? 0; + message.entryNumber = object.entryNumber ?? 0; + return message; + }, +}; + +function createBaseTournamentCarList(): TournamentCarList { + return { + car00: undefined, + car01: undefined, + car02: undefined, + car03: undefined, + car04: undefined, + car05: undefined, + car06: undefined, + car07: undefined, + car08: undefined, + car09: undefined, + car10: undefined, + car11: undefined, + car12: undefined, + car13: undefined, + car14: undefined, + car15: undefined, + car16: undefined, + car17: undefined, + car18: undefined, + car19: undefined, + car20: undefined, + car21: undefined, + car22: undefined, + car23: undefined, + car24: undefined, + car25: undefined, + car26: undefined, + car27: undefined, + car28: undefined, + car29: undefined, + car30: undefined, + car31: undefined, + }; +} + +export const TournamentCarList = { + encode( + message: TournamentCarList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car00 !== undefined) { + TournamentCar.encode(message.car00, writer.uint32(10).fork()).ldelim(); + } + if (message.car01 !== undefined) { + TournamentCar.encode(message.car01, writer.uint32(18).fork()).ldelim(); + } + if (message.car02 !== undefined) { + TournamentCar.encode(message.car02, writer.uint32(26).fork()).ldelim(); + } + if (message.car03 !== undefined) { + TournamentCar.encode(message.car03, writer.uint32(34).fork()).ldelim(); + } + if (message.car04 !== undefined) { + TournamentCar.encode(message.car04, writer.uint32(42).fork()).ldelim(); + } + if (message.car05 !== undefined) { + TournamentCar.encode(message.car05, writer.uint32(50).fork()).ldelim(); + } + if (message.car06 !== undefined) { + TournamentCar.encode(message.car06, writer.uint32(58).fork()).ldelim(); + } + if (message.car07 !== undefined) { + TournamentCar.encode(message.car07, writer.uint32(66).fork()).ldelim(); + } + if (message.car08 !== undefined) { + TournamentCar.encode(message.car08, writer.uint32(74).fork()).ldelim(); + } + if (message.car09 !== undefined) { + TournamentCar.encode(message.car09, writer.uint32(82).fork()).ldelim(); + } + if (message.car10 !== undefined) { + TournamentCar.encode(message.car10, writer.uint32(90).fork()).ldelim(); + } + if (message.car11 !== undefined) { + TournamentCar.encode(message.car11, writer.uint32(98).fork()).ldelim(); + } + if (message.car12 !== undefined) { + TournamentCar.encode(message.car12, writer.uint32(106).fork()).ldelim(); + } + if (message.car13 !== undefined) { + TournamentCar.encode(message.car13, writer.uint32(114).fork()).ldelim(); + } + if (message.car14 !== undefined) { + TournamentCar.encode(message.car14, writer.uint32(122).fork()).ldelim(); + } + if (message.car15 !== undefined) { + TournamentCar.encode(message.car15, writer.uint32(130).fork()).ldelim(); + } + if (message.car16 !== undefined) { + TournamentCar.encode(message.car16, writer.uint32(138).fork()).ldelim(); + } + if (message.car17 !== undefined) { + TournamentCar.encode(message.car17, writer.uint32(146).fork()).ldelim(); + } + if (message.car18 !== undefined) { + TournamentCar.encode(message.car18, writer.uint32(154).fork()).ldelim(); + } + if (message.car19 !== undefined) { + TournamentCar.encode(message.car19, writer.uint32(162).fork()).ldelim(); + } + if (message.car20 !== undefined) { + TournamentCar.encode(message.car20, writer.uint32(170).fork()).ldelim(); + } + if (message.car21 !== undefined) { + TournamentCar.encode(message.car21, writer.uint32(178).fork()).ldelim(); + } + if (message.car22 !== undefined) { + TournamentCar.encode(message.car22, writer.uint32(186).fork()).ldelim(); + } + if (message.car23 !== undefined) { + TournamentCar.encode(message.car23, writer.uint32(194).fork()).ldelim(); + } + if (message.car24 !== undefined) { + TournamentCar.encode(message.car24, writer.uint32(202).fork()).ldelim(); + } + if (message.car25 !== undefined) { + TournamentCar.encode(message.car25, writer.uint32(210).fork()).ldelim(); + } + if (message.car26 !== undefined) { + TournamentCar.encode(message.car26, writer.uint32(218).fork()).ldelim(); + } + if (message.car27 !== undefined) { + TournamentCar.encode(message.car27, writer.uint32(226).fork()).ldelim(); + } + if (message.car28 !== undefined) { + TournamentCar.encode(message.car28, writer.uint32(234).fork()).ldelim(); + } + if (message.car29 !== undefined) { + TournamentCar.encode(message.car29, writer.uint32(242).fork()).ldelim(); + } + if (message.car30 !== undefined) { + TournamentCar.encode(message.car30, writer.uint32(250).fork()).ldelim(); + } + if (message.car31 !== undefined) { + TournamentCar.encode(message.car31, writer.uint32(258).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): TournamentCarList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournamentCarList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car00 = TournamentCar.decode(reader, reader.uint32()); + break; + case 2: + message.car01 = TournamentCar.decode(reader, reader.uint32()); + break; + case 3: + message.car02 = TournamentCar.decode(reader, reader.uint32()); + break; + case 4: + message.car03 = TournamentCar.decode(reader, reader.uint32()); + break; + case 5: + message.car04 = TournamentCar.decode(reader, reader.uint32()); + break; + case 6: + message.car05 = TournamentCar.decode(reader, reader.uint32()); + break; + case 7: + message.car06 = TournamentCar.decode(reader, reader.uint32()); + break; + case 8: + message.car07 = TournamentCar.decode(reader, reader.uint32()); + break; + case 9: + message.car08 = TournamentCar.decode(reader, reader.uint32()); + break; + case 10: + message.car09 = TournamentCar.decode(reader, reader.uint32()); + break; + case 11: + message.car10 = TournamentCar.decode(reader, reader.uint32()); + break; + case 12: + message.car11 = TournamentCar.decode(reader, reader.uint32()); + break; + case 13: + message.car12 = TournamentCar.decode(reader, reader.uint32()); + break; + case 14: + message.car13 = TournamentCar.decode(reader, reader.uint32()); + break; + case 15: + message.car14 = TournamentCar.decode(reader, reader.uint32()); + break; + case 16: + message.car15 = TournamentCar.decode(reader, reader.uint32()); + break; + case 17: + message.car16 = TournamentCar.decode(reader, reader.uint32()); + break; + case 18: + message.car17 = TournamentCar.decode(reader, reader.uint32()); + break; + case 19: + message.car18 = TournamentCar.decode(reader, reader.uint32()); + break; + case 20: + message.car19 = TournamentCar.decode(reader, reader.uint32()); + break; + case 21: + message.car20 = TournamentCar.decode(reader, reader.uint32()); + break; + case 22: + message.car21 = TournamentCar.decode(reader, reader.uint32()); + break; + case 23: + message.car22 = TournamentCar.decode(reader, reader.uint32()); + break; + case 24: + message.car23 = TournamentCar.decode(reader, reader.uint32()); + break; + case 25: + message.car24 = TournamentCar.decode(reader, reader.uint32()); + break; + case 26: + message.car25 = TournamentCar.decode(reader, reader.uint32()); + break; + case 27: + message.car26 = TournamentCar.decode(reader, reader.uint32()); + break; + case 28: + message.car27 = TournamentCar.decode(reader, reader.uint32()); + break; + case 29: + message.car28 = TournamentCar.decode(reader, reader.uint32()); + break; + case 30: + message.car29 = TournamentCar.decode(reader, reader.uint32()); + break; + case 31: + message.car30 = TournamentCar.decode(reader, reader.uint32()); + break; + case 32: + message.car31 = TournamentCar.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TournamentCarList { + return { + car00: isSet(object.car00) + ? TournamentCar.fromJSON(object.car00) + : undefined, + car01: isSet(object.car01) + ? TournamentCar.fromJSON(object.car01) + : undefined, + car02: isSet(object.car02) + ? TournamentCar.fromJSON(object.car02) + : undefined, + car03: isSet(object.car03) + ? TournamentCar.fromJSON(object.car03) + : undefined, + car04: isSet(object.car04) + ? TournamentCar.fromJSON(object.car04) + : undefined, + car05: isSet(object.car05) + ? TournamentCar.fromJSON(object.car05) + : undefined, + car06: isSet(object.car06) + ? TournamentCar.fromJSON(object.car06) + : undefined, + car07: isSet(object.car07) + ? TournamentCar.fromJSON(object.car07) + : undefined, + car08: isSet(object.car08) + ? TournamentCar.fromJSON(object.car08) + : undefined, + car09: isSet(object.car09) + ? TournamentCar.fromJSON(object.car09) + : undefined, + car10: isSet(object.car10) + ? TournamentCar.fromJSON(object.car10) + : undefined, + car11: isSet(object.car11) + ? TournamentCar.fromJSON(object.car11) + : undefined, + car12: isSet(object.car12) + ? TournamentCar.fromJSON(object.car12) + : undefined, + car13: isSet(object.car13) + ? TournamentCar.fromJSON(object.car13) + : undefined, + car14: isSet(object.car14) + ? TournamentCar.fromJSON(object.car14) + : undefined, + car15: isSet(object.car15) + ? TournamentCar.fromJSON(object.car15) + : undefined, + car16: isSet(object.car16) + ? TournamentCar.fromJSON(object.car16) + : undefined, + car17: isSet(object.car17) + ? TournamentCar.fromJSON(object.car17) + : undefined, + car18: isSet(object.car18) + ? TournamentCar.fromJSON(object.car18) + : undefined, + car19: isSet(object.car19) + ? TournamentCar.fromJSON(object.car19) + : undefined, + car20: isSet(object.car20) + ? TournamentCar.fromJSON(object.car20) + : undefined, + car21: isSet(object.car21) + ? TournamentCar.fromJSON(object.car21) + : undefined, + car22: isSet(object.car22) + ? TournamentCar.fromJSON(object.car22) + : undefined, + car23: isSet(object.car23) + ? TournamentCar.fromJSON(object.car23) + : undefined, + car24: isSet(object.car24) + ? TournamentCar.fromJSON(object.car24) + : undefined, + car25: isSet(object.car25) + ? TournamentCar.fromJSON(object.car25) + : undefined, + car26: isSet(object.car26) + ? TournamentCar.fromJSON(object.car26) + : undefined, + car27: isSet(object.car27) + ? TournamentCar.fromJSON(object.car27) + : undefined, + car28: isSet(object.car28) + ? TournamentCar.fromJSON(object.car28) + : undefined, + car29: isSet(object.car29) + ? TournamentCar.fromJSON(object.car29) + : undefined, + car30: isSet(object.car30) + ? TournamentCar.fromJSON(object.car30) + : undefined, + car31: isSet(object.car31) + ? TournamentCar.fromJSON(object.car31) + : undefined, + }; + }, + + toJSON(message: TournamentCarList): unknown { + const obj: any = {}; + message.car00 !== undefined && + (obj.car00 = message.car00 + ? TournamentCar.toJSON(message.car00) + : undefined); + message.car01 !== undefined && + (obj.car01 = message.car01 + ? TournamentCar.toJSON(message.car01) + : undefined); + message.car02 !== undefined && + (obj.car02 = message.car02 + ? TournamentCar.toJSON(message.car02) + : undefined); + message.car03 !== undefined && + (obj.car03 = message.car03 + ? TournamentCar.toJSON(message.car03) + : undefined); + message.car04 !== undefined && + (obj.car04 = message.car04 + ? TournamentCar.toJSON(message.car04) + : undefined); + message.car05 !== undefined && + (obj.car05 = message.car05 + ? TournamentCar.toJSON(message.car05) + : undefined); + message.car06 !== undefined && + (obj.car06 = message.car06 + ? TournamentCar.toJSON(message.car06) + : undefined); + message.car07 !== undefined && + (obj.car07 = message.car07 + ? TournamentCar.toJSON(message.car07) + : undefined); + message.car08 !== undefined && + (obj.car08 = message.car08 + ? TournamentCar.toJSON(message.car08) + : undefined); + message.car09 !== undefined && + (obj.car09 = message.car09 + ? TournamentCar.toJSON(message.car09) + : undefined); + message.car10 !== undefined && + (obj.car10 = message.car10 + ? TournamentCar.toJSON(message.car10) + : undefined); + message.car11 !== undefined && + (obj.car11 = message.car11 + ? TournamentCar.toJSON(message.car11) + : undefined); + message.car12 !== undefined && + (obj.car12 = message.car12 + ? TournamentCar.toJSON(message.car12) + : undefined); + message.car13 !== undefined && + (obj.car13 = message.car13 + ? TournamentCar.toJSON(message.car13) + : undefined); + message.car14 !== undefined && + (obj.car14 = message.car14 + ? TournamentCar.toJSON(message.car14) + : undefined); + message.car15 !== undefined && + (obj.car15 = message.car15 + ? TournamentCar.toJSON(message.car15) + : undefined); + message.car16 !== undefined && + (obj.car16 = message.car16 + ? TournamentCar.toJSON(message.car16) + : undefined); + message.car17 !== undefined && + (obj.car17 = message.car17 + ? TournamentCar.toJSON(message.car17) + : undefined); + message.car18 !== undefined && + (obj.car18 = message.car18 + ? TournamentCar.toJSON(message.car18) + : undefined); + message.car19 !== undefined && + (obj.car19 = message.car19 + ? TournamentCar.toJSON(message.car19) + : undefined); + message.car20 !== undefined && + (obj.car20 = message.car20 + ? TournamentCar.toJSON(message.car20) + : undefined); + message.car21 !== undefined && + (obj.car21 = message.car21 + ? TournamentCar.toJSON(message.car21) + : undefined); + message.car22 !== undefined && + (obj.car22 = message.car22 + ? TournamentCar.toJSON(message.car22) + : undefined); + message.car23 !== undefined && + (obj.car23 = message.car23 + ? TournamentCar.toJSON(message.car23) + : undefined); + message.car24 !== undefined && + (obj.car24 = message.car24 + ? TournamentCar.toJSON(message.car24) + : undefined); + message.car25 !== undefined && + (obj.car25 = message.car25 + ? TournamentCar.toJSON(message.car25) + : undefined); + message.car26 !== undefined && + (obj.car26 = message.car26 + ? TournamentCar.toJSON(message.car26) + : undefined); + message.car27 !== undefined && + (obj.car27 = message.car27 + ? TournamentCar.toJSON(message.car27) + : undefined); + message.car28 !== undefined && + (obj.car28 = message.car28 + ? TournamentCar.toJSON(message.car28) + : undefined); + message.car29 !== undefined && + (obj.car29 = message.car29 + ? TournamentCar.toJSON(message.car29) + : undefined); + message.car30 !== undefined && + (obj.car30 = message.car30 + ? TournamentCar.toJSON(message.car30) + : undefined); + message.car31 !== undefined && + (obj.car31 = message.car31 + ? TournamentCar.toJSON(message.car31) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): TournamentCarList { + const message = createBaseTournamentCarList(); + message.car00 = + object.car00 !== undefined && object.car00 !== null + ? TournamentCar.fromPartial(object.car00) + : undefined; + message.car01 = + object.car01 !== undefined && object.car01 !== null + ? TournamentCar.fromPartial(object.car01) + : undefined; + message.car02 = + object.car02 !== undefined && object.car02 !== null + ? TournamentCar.fromPartial(object.car02) + : undefined; + message.car03 = + object.car03 !== undefined && object.car03 !== null + ? TournamentCar.fromPartial(object.car03) + : undefined; + message.car04 = + object.car04 !== undefined && object.car04 !== null + ? TournamentCar.fromPartial(object.car04) + : undefined; + message.car05 = + object.car05 !== undefined && object.car05 !== null + ? TournamentCar.fromPartial(object.car05) + : undefined; + message.car06 = + object.car06 !== undefined && object.car06 !== null + ? TournamentCar.fromPartial(object.car06) + : undefined; + message.car07 = + object.car07 !== undefined && object.car07 !== null + ? TournamentCar.fromPartial(object.car07) + : undefined; + message.car08 = + object.car08 !== undefined && object.car08 !== null + ? TournamentCar.fromPartial(object.car08) + : undefined; + message.car09 = + object.car09 !== undefined && object.car09 !== null + ? TournamentCar.fromPartial(object.car09) + : undefined; + message.car10 = + object.car10 !== undefined && object.car10 !== null + ? TournamentCar.fromPartial(object.car10) + : undefined; + message.car11 = + object.car11 !== undefined && object.car11 !== null + ? TournamentCar.fromPartial(object.car11) + : undefined; + message.car12 = + object.car12 !== undefined && object.car12 !== null + ? TournamentCar.fromPartial(object.car12) + : undefined; + message.car13 = + object.car13 !== undefined && object.car13 !== null + ? TournamentCar.fromPartial(object.car13) + : undefined; + message.car14 = + object.car14 !== undefined && object.car14 !== null + ? TournamentCar.fromPartial(object.car14) + : undefined; + message.car15 = + object.car15 !== undefined && object.car15 !== null + ? TournamentCar.fromPartial(object.car15) + : undefined; + message.car16 = + object.car16 !== undefined && object.car16 !== null + ? TournamentCar.fromPartial(object.car16) + : undefined; + message.car17 = + object.car17 !== undefined && object.car17 !== null + ? TournamentCar.fromPartial(object.car17) + : undefined; + message.car18 = + object.car18 !== undefined && object.car18 !== null + ? TournamentCar.fromPartial(object.car18) + : undefined; + message.car19 = + object.car19 !== undefined && object.car19 !== null + ? TournamentCar.fromPartial(object.car19) + : undefined; + message.car20 = + object.car20 !== undefined && object.car20 !== null + ? TournamentCar.fromPartial(object.car20) + : undefined; + message.car21 = + object.car21 !== undefined && object.car21 !== null + ? TournamentCar.fromPartial(object.car21) + : undefined; + message.car22 = + object.car22 !== undefined && object.car22 !== null + ? TournamentCar.fromPartial(object.car22) + : undefined; + message.car23 = + object.car23 !== undefined && object.car23 !== null + ? TournamentCar.fromPartial(object.car23) + : undefined; + message.car24 = + object.car24 !== undefined && object.car24 !== null + ? TournamentCar.fromPartial(object.car24) + : undefined; + message.car25 = + object.car25 !== undefined && object.car25 !== null + ? TournamentCar.fromPartial(object.car25) + : undefined; + message.car26 = + object.car26 !== undefined && object.car26 !== null + ? TournamentCar.fromPartial(object.car26) + : undefined; + message.car27 = + object.car27 !== undefined && object.car27 !== null + ? TournamentCar.fromPartial(object.car27) + : undefined; + message.car28 = + object.car28 !== undefined && object.car28 !== null + ? TournamentCar.fromPartial(object.car28) + : undefined; + message.car29 = + object.car29 !== undefined && object.car29 !== null + ? TournamentCar.fromPartial(object.car29) + : undefined; + message.car30 = + object.car30 !== undefined && object.car30 !== null + ? TournamentCar.fromPartial(object.car30) + : undefined; + message.car31 = + object.car31 !== undefined && object.car31 !== null + ? TournamentCar.fromPartial(object.car31) + : undefined; + return message; + }, +}; + +function createBaseTournamentRaceData(): TournamentRaceData { + return { + raceNumber: 0, + roundNumber: 0, + gameNumber: 0, + player00: 0, + player01: 0, + player02: 0, + player03: 0, + result00: 0, + result01: 0, + result02: 0, + result03: 0, + }; +} + +export const TournamentRaceData = { + encode( + message: TournamentRaceData, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.raceNumber !== 0) { + writer.uint32(8).uint32(message.raceNumber); + } + if (message.roundNumber !== 0) { + writer.uint32(16).uint32(message.roundNumber); + } + if (message.gameNumber !== 0) { + writer.uint32(24).uint32(message.gameNumber); + } + if (message.player00 !== 0) { + writer.uint32(32).sint32(message.player00); + } + if (message.player01 !== 0) { + writer.uint32(40).sint32(message.player01); + } + if (message.player02 !== 0) { + writer.uint32(48).sint32(message.player02); + } + if (message.player03 !== 0) { + writer.uint32(56).sint32(message.player03); + } + if (message.result00 !== 0) { + writer.uint32(64).sint32(message.result00); + } + if (message.result01 !== 0) { + writer.uint32(72).sint32(message.result01); + } + if (message.result02 !== 0) { + writer.uint32(80).sint32(message.result02); + } + if (message.result03 !== 0) { + writer.uint32(88).sint32(message.result03); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): TournamentRaceData { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournamentRaceData(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.raceNumber = reader.uint32(); + break; + case 2: + message.roundNumber = reader.uint32(); + break; + case 3: + message.gameNumber = reader.uint32(); + break; + case 4: + message.player00 = reader.sint32(); + break; + case 5: + message.player01 = reader.sint32(); + break; + case 6: + message.player02 = reader.sint32(); + break; + case 7: + message.player03 = reader.sint32(); + break; + case 8: + message.result00 = reader.sint32(); + break; + case 9: + message.result01 = reader.sint32(); + break; + case 10: + message.result02 = reader.sint32(); + break; + case 11: + message.result03 = reader.sint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TournamentRaceData { + return { + raceNumber: isSet(object.raceNumber) ? Number(object.raceNumber) : 0, + roundNumber: isSet(object.roundNumber) ? Number(object.roundNumber) : 0, + gameNumber: isSet(object.gameNumber) ? Number(object.gameNumber) : 0, + player00: isSet(object.player00) ? Number(object.player00) : 0, + player01: isSet(object.player01) ? Number(object.player01) : 0, + player02: isSet(object.player02) ? Number(object.player02) : 0, + player03: isSet(object.player03) ? Number(object.player03) : 0, + result00: isSet(object.result00) ? Number(object.result00) : 0, + result01: isSet(object.result01) ? Number(object.result01) : 0, + result02: isSet(object.result02) ? Number(object.result02) : 0, + result03: isSet(object.result03) ? Number(object.result03) : 0, + }; + }, + + toJSON(message: TournamentRaceData): unknown { + const obj: any = {}; + message.raceNumber !== undefined && + (obj.raceNumber = Math.round(message.raceNumber)); + message.roundNumber !== undefined && + (obj.roundNumber = Math.round(message.roundNumber)); + message.gameNumber !== undefined && + (obj.gameNumber = Math.round(message.gameNumber)); + message.player00 !== undefined && + (obj.player00 = Math.round(message.player00)); + message.player01 !== undefined && + (obj.player01 = Math.round(message.player01)); + message.player02 !== undefined && + (obj.player02 = Math.round(message.player02)); + message.player03 !== undefined && + (obj.player03 = Math.round(message.player03)); + message.result00 !== undefined && + (obj.result00 = Math.round(message.result00)); + message.result01 !== undefined && + (obj.result01 = Math.round(message.result01)); + message.result02 !== undefined && + (obj.result02 = Math.round(message.result02)); + message.result03 !== undefined && + (obj.result03 = Math.round(message.result03)); + return obj; + }, + + fromPartial, I>>( + object: I + ): TournamentRaceData { + const message = createBaseTournamentRaceData(); + message.raceNumber = object.raceNumber ?? 0; + message.roundNumber = object.roundNumber ?? 0; + message.gameNumber = object.gameNumber ?? 0; + message.player00 = object.player00 ?? 0; + message.player01 = object.player01 ?? 0; + message.player02 = object.player02 ?? 0; + message.player03 = object.player03 ?? 0; + message.result00 = object.result00 ?? 0; + message.result01 = object.result01 ?? 0; + message.result02 = object.result02 ?? 0; + message.result03 = object.result03 ?? 0; + return message; + }, +}; + +function createBaseTournamentRaceDataList(): TournamentRaceDataList { + return { + raceData00: undefined, + raceData01: undefined, + raceData02: undefined, + raceData03: undefined, + raceData04: undefined, + raceData05: undefined, + raceData06: undefined, + raceData07: undefined, + raceData08: undefined, + raceData09: undefined, + raceData10: undefined, + raceData11: undefined, + raceData12: undefined, + raceData13: undefined, + raceData14: undefined, + raceData15: undefined, + raceData16: undefined, + raceData17: undefined, + raceData18: undefined, + raceData19: undefined, + raceData20: undefined, + raceData21: undefined, + raceData22: undefined, + raceData23: undefined, + raceData24: undefined, + raceData25: undefined, + raceData26: undefined, + raceData27: undefined, + raceData28: undefined, + raceData29: undefined, + raceData30: undefined, + raceData31: undefined, + raceData32: undefined, + raceData33: undefined, + raceData34: undefined, + }; +} + +export const TournamentRaceDataList = { + encode( + message: TournamentRaceDataList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.raceData00 !== undefined) { + TournamentRaceData.encode( + message.raceData00, + writer.uint32(10).fork() + ).ldelim(); + } + if (message.raceData01 !== undefined) { + TournamentRaceData.encode( + message.raceData01, + writer.uint32(18).fork() + ).ldelim(); + } + if (message.raceData02 !== undefined) { + TournamentRaceData.encode( + message.raceData02, + writer.uint32(26).fork() + ).ldelim(); + } + if (message.raceData03 !== undefined) { + TournamentRaceData.encode( + message.raceData03, + writer.uint32(34).fork() + ).ldelim(); + } + if (message.raceData04 !== undefined) { + TournamentRaceData.encode( + message.raceData04, + writer.uint32(42).fork() + ).ldelim(); + } + if (message.raceData05 !== undefined) { + TournamentRaceData.encode( + message.raceData05, + writer.uint32(50).fork() + ).ldelim(); + } + if (message.raceData06 !== undefined) { + TournamentRaceData.encode( + message.raceData06, + writer.uint32(58).fork() + ).ldelim(); + } + if (message.raceData07 !== undefined) { + TournamentRaceData.encode( + message.raceData07, + writer.uint32(66).fork() + ).ldelim(); + } + if (message.raceData08 !== undefined) { + TournamentRaceData.encode( + message.raceData08, + writer.uint32(74).fork() + ).ldelim(); + } + if (message.raceData09 !== undefined) { + TournamentRaceData.encode( + message.raceData09, + writer.uint32(82).fork() + ).ldelim(); + } + if (message.raceData10 !== undefined) { + TournamentRaceData.encode( + message.raceData10, + writer.uint32(90).fork() + ).ldelim(); + } + if (message.raceData11 !== undefined) { + TournamentRaceData.encode( + message.raceData11, + writer.uint32(98).fork() + ).ldelim(); + } + if (message.raceData12 !== undefined) { + TournamentRaceData.encode( + message.raceData12, + writer.uint32(106).fork() + ).ldelim(); + } + if (message.raceData13 !== undefined) { + TournamentRaceData.encode( + message.raceData13, + writer.uint32(114).fork() + ).ldelim(); + } + if (message.raceData14 !== undefined) { + TournamentRaceData.encode( + message.raceData14, + writer.uint32(122).fork() + ).ldelim(); + } + if (message.raceData15 !== undefined) { + TournamentRaceData.encode( + message.raceData15, + writer.uint32(130).fork() + ).ldelim(); + } + if (message.raceData16 !== undefined) { + TournamentRaceData.encode( + message.raceData16, + writer.uint32(138).fork() + ).ldelim(); + } + if (message.raceData17 !== undefined) { + TournamentRaceData.encode( + message.raceData17, + writer.uint32(146).fork() + ).ldelim(); + } + if (message.raceData18 !== undefined) { + TournamentRaceData.encode( + message.raceData18, + writer.uint32(154).fork() + ).ldelim(); + } + if (message.raceData19 !== undefined) { + TournamentRaceData.encode( + message.raceData19, + writer.uint32(162).fork() + ).ldelim(); + } + if (message.raceData20 !== undefined) { + TournamentRaceData.encode( + message.raceData20, + writer.uint32(170).fork() + ).ldelim(); + } + if (message.raceData21 !== undefined) { + TournamentRaceData.encode( + message.raceData21, + writer.uint32(178).fork() + ).ldelim(); + } + if (message.raceData22 !== undefined) { + TournamentRaceData.encode( + message.raceData22, + writer.uint32(186).fork() + ).ldelim(); + } + if (message.raceData23 !== undefined) { + TournamentRaceData.encode( + message.raceData23, + writer.uint32(194).fork() + ).ldelim(); + } + if (message.raceData24 !== undefined) { + TournamentRaceData.encode( + message.raceData24, + writer.uint32(202).fork() + ).ldelim(); + } + if (message.raceData25 !== undefined) { + TournamentRaceData.encode( + message.raceData25, + writer.uint32(210).fork() + ).ldelim(); + } + if (message.raceData26 !== undefined) { + TournamentRaceData.encode( + message.raceData26, + writer.uint32(218).fork() + ).ldelim(); + } + if (message.raceData27 !== undefined) { + TournamentRaceData.encode( + message.raceData27, + writer.uint32(226).fork() + ).ldelim(); + } + if (message.raceData28 !== undefined) { + TournamentRaceData.encode( + message.raceData28, + writer.uint32(234).fork() + ).ldelim(); + } + if (message.raceData29 !== undefined) { + TournamentRaceData.encode( + message.raceData29, + writer.uint32(242).fork() + ).ldelim(); + } + if (message.raceData30 !== undefined) { + TournamentRaceData.encode( + message.raceData30, + writer.uint32(250).fork() + ).ldelim(); + } + if (message.raceData31 !== undefined) { + TournamentRaceData.encode( + message.raceData31, + writer.uint32(258).fork() + ).ldelim(); + } + if (message.raceData32 !== undefined) { + TournamentRaceData.encode( + message.raceData32, + writer.uint32(266).fork() + ).ldelim(); + } + if (message.raceData33 !== undefined) { + TournamentRaceData.encode( + message.raceData33, + writer.uint32(274).fork() + ).ldelim(); + } + if (message.raceData34 !== undefined) { + TournamentRaceData.encode( + message.raceData34, + writer.uint32(282).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): TournamentRaceDataList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournamentRaceDataList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.raceData00 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 2: + message.raceData01 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 3: + message.raceData02 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 4: + message.raceData03 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 5: + message.raceData04 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 6: + message.raceData05 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 7: + message.raceData06 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 8: + message.raceData07 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 9: + message.raceData08 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 10: + message.raceData09 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 11: + message.raceData10 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 12: + message.raceData11 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 13: + message.raceData12 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 14: + message.raceData13 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 15: + message.raceData14 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 16: + message.raceData15 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 17: + message.raceData16 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 18: + message.raceData17 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 19: + message.raceData18 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 20: + message.raceData19 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 21: + message.raceData20 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 22: + message.raceData21 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 23: + message.raceData22 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 24: + message.raceData23 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 25: + message.raceData24 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 26: + message.raceData25 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 27: + message.raceData26 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 28: + message.raceData27 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 29: + message.raceData28 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 30: + message.raceData29 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 31: + message.raceData30 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 32: + message.raceData31 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 33: + message.raceData32 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 34: + message.raceData33 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + case 35: + message.raceData34 = TournamentRaceData.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TournamentRaceDataList { + return { + raceData00: isSet(object.raceData00) + ? TournamentRaceData.fromJSON(object.raceData00) + : undefined, + raceData01: isSet(object.raceData01) + ? TournamentRaceData.fromJSON(object.raceData01) + : undefined, + raceData02: isSet(object.raceData02) + ? TournamentRaceData.fromJSON(object.raceData02) + : undefined, + raceData03: isSet(object.raceData03) + ? TournamentRaceData.fromJSON(object.raceData03) + : undefined, + raceData04: isSet(object.raceData04) + ? TournamentRaceData.fromJSON(object.raceData04) + : undefined, + raceData05: isSet(object.raceData05) + ? TournamentRaceData.fromJSON(object.raceData05) + : undefined, + raceData06: isSet(object.raceData06) + ? TournamentRaceData.fromJSON(object.raceData06) + : undefined, + raceData07: isSet(object.raceData07) + ? TournamentRaceData.fromJSON(object.raceData07) + : undefined, + raceData08: isSet(object.raceData08) + ? TournamentRaceData.fromJSON(object.raceData08) + : undefined, + raceData09: isSet(object.raceData09) + ? TournamentRaceData.fromJSON(object.raceData09) + : undefined, + raceData10: isSet(object.raceData10) + ? TournamentRaceData.fromJSON(object.raceData10) + : undefined, + raceData11: isSet(object.raceData11) + ? TournamentRaceData.fromJSON(object.raceData11) + : undefined, + raceData12: isSet(object.raceData12) + ? TournamentRaceData.fromJSON(object.raceData12) + : undefined, + raceData13: isSet(object.raceData13) + ? TournamentRaceData.fromJSON(object.raceData13) + : undefined, + raceData14: isSet(object.raceData14) + ? TournamentRaceData.fromJSON(object.raceData14) + : undefined, + raceData15: isSet(object.raceData15) + ? TournamentRaceData.fromJSON(object.raceData15) + : undefined, + raceData16: isSet(object.raceData16) + ? TournamentRaceData.fromJSON(object.raceData16) + : undefined, + raceData17: isSet(object.raceData17) + ? TournamentRaceData.fromJSON(object.raceData17) + : undefined, + raceData18: isSet(object.raceData18) + ? TournamentRaceData.fromJSON(object.raceData18) + : undefined, + raceData19: isSet(object.raceData19) + ? TournamentRaceData.fromJSON(object.raceData19) + : undefined, + raceData20: isSet(object.raceData20) + ? TournamentRaceData.fromJSON(object.raceData20) + : undefined, + raceData21: isSet(object.raceData21) + ? TournamentRaceData.fromJSON(object.raceData21) + : undefined, + raceData22: isSet(object.raceData22) + ? TournamentRaceData.fromJSON(object.raceData22) + : undefined, + raceData23: isSet(object.raceData23) + ? TournamentRaceData.fromJSON(object.raceData23) + : undefined, + raceData24: isSet(object.raceData24) + ? TournamentRaceData.fromJSON(object.raceData24) + : undefined, + raceData25: isSet(object.raceData25) + ? TournamentRaceData.fromJSON(object.raceData25) + : undefined, + raceData26: isSet(object.raceData26) + ? TournamentRaceData.fromJSON(object.raceData26) + : undefined, + raceData27: isSet(object.raceData27) + ? TournamentRaceData.fromJSON(object.raceData27) + : undefined, + raceData28: isSet(object.raceData28) + ? TournamentRaceData.fromJSON(object.raceData28) + : undefined, + raceData29: isSet(object.raceData29) + ? TournamentRaceData.fromJSON(object.raceData29) + : undefined, + raceData30: isSet(object.raceData30) + ? TournamentRaceData.fromJSON(object.raceData30) + : undefined, + raceData31: isSet(object.raceData31) + ? TournamentRaceData.fromJSON(object.raceData31) + : undefined, + raceData32: isSet(object.raceData32) + ? TournamentRaceData.fromJSON(object.raceData32) + : undefined, + raceData33: isSet(object.raceData33) + ? TournamentRaceData.fromJSON(object.raceData33) + : undefined, + raceData34: isSet(object.raceData34) + ? TournamentRaceData.fromJSON(object.raceData34) + : undefined, + }; + }, + + toJSON(message: TournamentRaceDataList): unknown { + const obj: any = {}; + message.raceData00 !== undefined && + (obj.raceData00 = message.raceData00 + ? TournamentRaceData.toJSON(message.raceData00) + : undefined); + message.raceData01 !== undefined && + (obj.raceData01 = message.raceData01 + ? TournamentRaceData.toJSON(message.raceData01) + : undefined); + message.raceData02 !== undefined && + (obj.raceData02 = message.raceData02 + ? TournamentRaceData.toJSON(message.raceData02) + : undefined); + message.raceData03 !== undefined && + (obj.raceData03 = message.raceData03 + ? TournamentRaceData.toJSON(message.raceData03) + : undefined); + message.raceData04 !== undefined && + (obj.raceData04 = message.raceData04 + ? TournamentRaceData.toJSON(message.raceData04) + : undefined); + message.raceData05 !== undefined && + (obj.raceData05 = message.raceData05 + ? TournamentRaceData.toJSON(message.raceData05) + : undefined); + message.raceData06 !== undefined && + (obj.raceData06 = message.raceData06 + ? TournamentRaceData.toJSON(message.raceData06) + : undefined); + message.raceData07 !== undefined && + (obj.raceData07 = message.raceData07 + ? TournamentRaceData.toJSON(message.raceData07) + : undefined); + message.raceData08 !== undefined && + (obj.raceData08 = message.raceData08 + ? TournamentRaceData.toJSON(message.raceData08) + : undefined); + message.raceData09 !== undefined && + (obj.raceData09 = message.raceData09 + ? TournamentRaceData.toJSON(message.raceData09) + : undefined); + message.raceData10 !== undefined && + (obj.raceData10 = message.raceData10 + ? TournamentRaceData.toJSON(message.raceData10) + : undefined); + message.raceData11 !== undefined && + (obj.raceData11 = message.raceData11 + ? TournamentRaceData.toJSON(message.raceData11) + : undefined); + message.raceData12 !== undefined && + (obj.raceData12 = message.raceData12 + ? TournamentRaceData.toJSON(message.raceData12) + : undefined); + message.raceData13 !== undefined && + (obj.raceData13 = message.raceData13 + ? TournamentRaceData.toJSON(message.raceData13) + : undefined); + message.raceData14 !== undefined && + (obj.raceData14 = message.raceData14 + ? TournamentRaceData.toJSON(message.raceData14) + : undefined); + message.raceData15 !== undefined && + (obj.raceData15 = message.raceData15 + ? TournamentRaceData.toJSON(message.raceData15) + : undefined); + message.raceData16 !== undefined && + (obj.raceData16 = message.raceData16 + ? TournamentRaceData.toJSON(message.raceData16) + : undefined); + message.raceData17 !== undefined && + (obj.raceData17 = message.raceData17 + ? TournamentRaceData.toJSON(message.raceData17) + : undefined); + message.raceData18 !== undefined && + (obj.raceData18 = message.raceData18 + ? TournamentRaceData.toJSON(message.raceData18) + : undefined); + message.raceData19 !== undefined && + (obj.raceData19 = message.raceData19 + ? TournamentRaceData.toJSON(message.raceData19) + : undefined); + message.raceData20 !== undefined && + (obj.raceData20 = message.raceData20 + ? TournamentRaceData.toJSON(message.raceData20) + : undefined); + message.raceData21 !== undefined && + (obj.raceData21 = message.raceData21 + ? TournamentRaceData.toJSON(message.raceData21) + : undefined); + message.raceData22 !== undefined && + (obj.raceData22 = message.raceData22 + ? TournamentRaceData.toJSON(message.raceData22) + : undefined); + message.raceData23 !== undefined && + (obj.raceData23 = message.raceData23 + ? TournamentRaceData.toJSON(message.raceData23) + : undefined); + message.raceData24 !== undefined && + (obj.raceData24 = message.raceData24 + ? TournamentRaceData.toJSON(message.raceData24) + : undefined); + message.raceData25 !== undefined && + (obj.raceData25 = message.raceData25 + ? TournamentRaceData.toJSON(message.raceData25) + : undefined); + message.raceData26 !== undefined && + (obj.raceData26 = message.raceData26 + ? TournamentRaceData.toJSON(message.raceData26) + : undefined); + message.raceData27 !== undefined && + (obj.raceData27 = message.raceData27 + ? TournamentRaceData.toJSON(message.raceData27) + : undefined); + message.raceData28 !== undefined && + (obj.raceData28 = message.raceData28 + ? TournamentRaceData.toJSON(message.raceData28) + : undefined); + message.raceData29 !== undefined && + (obj.raceData29 = message.raceData29 + ? TournamentRaceData.toJSON(message.raceData29) + : undefined); + message.raceData30 !== undefined && + (obj.raceData30 = message.raceData30 + ? TournamentRaceData.toJSON(message.raceData30) + : undefined); + message.raceData31 !== undefined && + (obj.raceData31 = message.raceData31 + ? TournamentRaceData.toJSON(message.raceData31) + : undefined); + message.raceData32 !== undefined && + (obj.raceData32 = message.raceData32 + ? TournamentRaceData.toJSON(message.raceData32) + : undefined); + message.raceData33 !== undefined && + (obj.raceData33 = message.raceData33 + ? TournamentRaceData.toJSON(message.raceData33) + : undefined); + message.raceData34 !== undefined && + (obj.raceData34 = message.raceData34 + ? TournamentRaceData.toJSON(message.raceData34) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): TournamentRaceDataList { + const message = createBaseTournamentRaceDataList(); + message.raceData00 = + object.raceData00 !== undefined && object.raceData00 !== null + ? TournamentRaceData.fromPartial(object.raceData00) + : undefined; + message.raceData01 = + object.raceData01 !== undefined && object.raceData01 !== null + ? TournamentRaceData.fromPartial(object.raceData01) + : undefined; + message.raceData02 = + object.raceData02 !== undefined && object.raceData02 !== null + ? TournamentRaceData.fromPartial(object.raceData02) + : undefined; + message.raceData03 = + object.raceData03 !== undefined && object.raceData03 !== null + ? TournamentRaceData.fromPartial(object.raceData03) + : undefined; + message.raceData04 = + object.raceData04 !== undefined && object.raceData04 !== null + ? TournamentRaceData.fromPartial(object.raceData04) + : undefined; + message.raceData05 = + object.raceData05 !== undefined && object.raceData05 !== null + ? TournamentRaceData.fromPartial(object.raceData05) + : undefined; + message.raceData06 = + object.raceData06 !== undefined && object.raceData06 !== null + ? TournamentRaceData.fromPartial(object.raceData06) + : undefined; + message.raceData07 = + object.raceData07 !== undefined && object.raceData07 !== null + ? TournamentRaceData.fromPartial(object.raceData07) + : undefined; + message.raceData08 = + object.raceData08 !== undefined && object.raceData08 !== null + ? TournamentRaceData.fromPartial(object.raceData08) + : undefined; + message.raceData09 = + object.raceData09 !== undefined && object.raceData09 !== null + ? TournamentRaceData.fromPartial(object.raceData09) + : undefined; + message.raceData10 = + object.raceData10 !== undefined && object.raceData10 !== null + ? TournamentRaceData.fromPartial(object.raceData10) + : undefined; + message.raceData11 = + object.raceData11 !== undefined && object.raceData11 !== null + ? TournamentRaceData.fromPartial(object.raceData11) + : undefined; + message.raceData12 = + object.raceData12 !== undefined && object.raceData12 !== null + ? TournamentRaceData.fromPartial(object.raceData12) + : undefined; + message.raceData13 = + object.raceData13 !== undefined && object.raceData13 !== null + ? TournamentRaceData.fromPartial(object.raceData13) + : undefined; + message.raceData14 = + object.raceData14 !== undefined && object.raceData14 !== null + ? TournamentRaceData.fromPartial(object.raceData14) + : undefined; + message.raceData15 = + object.raceData15 !== undefined && object.raceData15 !== null + ? TournamentRaceData.fromPartial(object.raceData15) + : undefined; + message.raceData16 = + object.raceData16 !== undefined && object.raceData16 !== null + ? TournamentRaceData.fromPartial(object.raceData16) + : undefined; + message.raceData17 = + object.raceData17 !== undefined && object.raceData17 !== null + ? TournamentRaceData.fromPartial(object.raceData17) + : undefined; + message.raceData18 = + object.raceData18 !== undefined && object.raceData18 !== null + ? TournamentRaceData.fromPartial(object.raceData18) + : undefined; + message.raceData19 = + object.raceData19 !== undefined && object.raceData19 !== null + ? TournamentRaceData.fromPartial(object.raceData19) + : undefined; + message.raceData20 = + object.raceData20 !== undefined && object.raceData20 !== null + ? TournamentRaceData.fromPartial(object.raceData20) + : undefined; + message.raceData21 = + object.raceData21 !== undefined && object.raceData21 !== null + ? TournamentRaceData.fromPartial(object.raceData21) + : undefined; + message.raceData22 = + object.raceData22 !== undefined && object.raceData22 !== null + ? TournamentRaceData.fromPartial(object.raceData22) + : undefined; + message.raceData23 = + object.raceData23 !== undefined && object.raceData23 !== null + ? TournamentRaceData.fromPartial(object.raceData23) + : undefined; + message.raceData24 = + object.raceData24 !== undefined && object.raceData24 !== null + ? TournamentRaceData.fromPartial(object.raceData24) + : undefined; + message.raceData25 = + object.raceData25 !== undefined && object.raceData25 !== null + ? TournamentRaceData.fromPartial(object.raceData25) + : undefined; + message.raceData26 = + object.raceData26 !== undefined && object.raceData26 !== null + ? TournamentRaceData.fromPartial(object.raceData26) + : undefined; + message.raceData27 = + object.raceData27 !== undefined && object.raceData27 !== null + ? TournamentRaceData.fromPartial(object.raceData27) + : undefined; + message.raceData28 = + object.raceData28 !== undefined && object.raceData28 !== null + ? TournamentRaceData.fromPartial(object.raceData28) + : undefined; + message.raceData29 = + object.raceData29 !== undefined && object.raceData29 !== null + ? TournamentRaceData.fromPartial(object.raceData29) + : undefined; + message.raceData30 = + object.raceData30 !== undefined && object.raceData30 !== null + ? TournamentRaceData.fromPartial(object.raceData30) + : undefined; + message.raceData31 = + object.raceData31 !== undefined && object.raceData31 !== null + ? TournamentRaceData.fromPartial(object.raceData31) + : undefined; + message.raceData32 = + object.raceData32 !== undefined && object.raceData32 !== null + ? TournamentRaceData.fromPartial(object.raceData32) + : undefined; + message.raceData33 = + object.raceData33 !== undefined && object.raceData33 !== null + ? TournamentRaceData.fromPartial(object.raceData33) + : undefined; + message.raceData34 = + object.raceData34 !== undefined && object.raceData34 !== null + ? TournamentRaceData.fromPartial(object.raceData34) + : undefined; + return message; + }, +}; + +function createBaseTournamentResult(): TournamentResult { + return { car: undefined, rank: 0, entryNumber: 0 }; +} + +export const TournamentResult = { + encode( + message: TournamentResult, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.rank !== 0) { + writer.uint32(16).sint32(message.rank); + } + if (message.entryNumber !== 0) { + writer.uint32(24).sint32(message.entryNumber); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): TournamentResult { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournamentResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.rank = reader.sint32(); + break; + case 3: + message.entryNumber = reader.sint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TournamentResult { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + rank: isSet(object.rank) ? Number(object.rank) : 0, + entryNumber: isSet(object.entryNumber) ? Number(object.entryNumber) : 0, + }; + }, + + toJSON(message: TournamentResult): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.rank !== undefined && (obj.rank = Math.round(message.rank)); + message.entryNumber !== undefined && + (obj.entryNumber = Math.round(message.entryNumber)); + return obj; + }, + + fromPartial, I>>( + object: I + ): TournamentResult { + const message = createBaseTournamentResult(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.rank = object.rank ?? 0; + message.entryNumber = object.entryNumber ?? 0; + return message; + }, +}; + +function createBaseTournamentResultList(): TournamentResultList { + return { + result00: undefined, + result01: undefined, + result02: undefined, + result03: undefined, + }; +} + +export const TournamentResultList = { + encode( + message: TournamentResultList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.result00 !== undefined) { + TournamentResult.encode( + message.result00, + writer.uint32(10).fork() + ).ldelim(); + } + if (message.result01 !== undefined) { + TournamentResult.encode( + message.result01, + writer.uint32(18).fork() + ).ldelim(); + } + if (message.result02 !== undefined) { + TournamentResult.encode( + message.result02, + writer.uint32(26).fork() + ).ldelim(); + } + if (message.result03 !== undefined) { + TournamentResult.encode( + message.result03, + writer.uint32(34).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): TournamentResultList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournamentResultList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.result00 = TournamentResult.decode(reader, reader.uint32()); + break; + case 2: + message.result01 = TournamentResult.decode(reader, reader.uint32()); + break; + case 3: + message.result02 = TournamentResult.decode(reader, reader.uint32()); + break; + case 4: + message.result03 = TournamentResult.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TournamentResultList { + return { + result00: isSet(object.result00) + ? TournamentResult.fromJSON(object.result00) + : undefined, + result01: isSet(object.result01) + ? TournamentResult.fromJSON(object.result01) + : undefined, + result02: isSet(object.result02) + ? TournamentResult.fromJSON(object.result02) + : undefined, + result03: isSet(object.result03) + ? TournamentResult.fromJSON(object.result03) + : undefined, + }; + }, + + toJSON(message: TournamentResultList): unknown { + const obj: any = {}; + message.result00 !== undefined && + (obj.result00 = message.result00 + ? TournamentResult.toJSON(message.result00) + : undefined); + message.result01 !== undefined && + (obj.result01 = message.result01 + ? TournamentResult.toJSON(message.result01) + : undefined); + message.result02 !== undefined && + (obj.result02 = message.result02 + ? TournamentResult.toJSON(message.result02) + : undefined); + message.result03 !== undefined && + (obj.result03 = message.result03 + ? TournamentResult.toJSON(message.result03) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): TournamentResultList { + const message = createBaseTournamentResultList(); + message.result00 = + object.result00 !== undefined && object.result00 !== null + ? TournamentResult.fromPartial(object.result00) + : undefined; + message.result01 = + object.result01 !== undefined && object.result01 !== null + ? TournamentResult.fromPartial(object.result01) + : undefined; + message.result02 = + object.result02 !== undefined && object.result02 !== null + ? TournamentResult.fromPartial(object.result02) + : undefined; + message.result03 = + object.result03 !== undefined && object.result03 !== null + ? TournamentResult.fromPartial(object.result03) + : undefined; + return message; + }, +}; + +function createBaseTournament(): Tournament { + return { + isEnableTournament: false, + isClearTournament: false, + isEntryPlayerOnly: false, + carList: undefined, + raceDataList: undefined, + isTournamentOn: false, + holdYear: 0, + holdMonth: 0, + holdDay: 0, + entryHour: 0, + entryMinute: 0, + tournamentStartHour: 0, + tournamentStartMinute: 0, + competitionNum: 0, + participantNum: 0, + surviverNumOfFirstRace: 0, + nowRound: 0, + playingGameNumber: 0, + isConfirmTournamentResult: false, + isTournamentEntry: false, + resultList: undefined, + hasCommendationStarted: false, + isCommendationRankAppeared: false, + isCommendationEnded: false, + isNextRank: false, + commendationPage: 0, + showCommendationAgain: false, + }; +} + +export const Tournament = { + encode( + message: Tournament, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.isEnableTournament === true) { + writer.uint32(8).bool(message.isEnableTournament); + } + if (message.isClearTournament === true) { + writer.uint32(16).bool(message.isClearTournament); + } + if (message.isEntryPlayerOnly === true) { + writer.uint32(24).bool(message.isEntryPlayerOnly); + } + if (message.carList !== undefined) { + TournamentCarList.encode( + message.carList, + writer.uint32(34).fork() + ).ldelim(); + } + if (message.raceDataList !== undefined) { + TournamentRaceDataList.encode( + message.raceDataList, + writer.uint32(42).fork() + ).ldelim(); + } + if (message.isTournamentOn === true) { + writer.uint32(48).bool(message.isTournamentOn); + } + if (message.holdYear !== 0) { + writer.uint32(56).uint32(message.holdYear); + } + if (message.holdMonth !== 0) { + writer.uint32(64).uint32(message.holdMonth); + } + if (message.holdDay !== 0) { + writer.uint32(72).uint32(message.holdDay); + } + if (message.entryHour !== 0) { + writer.uint32(80).uint32(message.entryHour); + } + if (message.entryMinute !== 0) { + writer.uint32(88).uint32(message.entryMinute); + } + if (message.tournamentStartHour !== 0) { + writer.uint32(96).uint32(message.tournamentStartHour); + } + if (message.tournamentStartMinute !== 0) { + writer.uint32(104).uint32(message.tournamentStartMinute); + } + if (message.competitionNum !== 0) { + writer.uint32(112).uint32(message.competitionNum); + } + if (message.participantNum !== 0) { + writer.uint32(120).uint32(message.participantNum); + } + if (message.surviverNumOfFirstRace !== 0) { + writer.uint32(128).uint32(message.surviverNumOfFirstRace); + } + if (message.nowRound !== 0) { + writer.uint32(136).uint32(message.nowRound); + } + if (message.playingGameNumber !== 0) { + writer.uint32(144).sint32(message.playingGameNumber); + } + if (message.isConfirmTournamentResult === true) { + writer.uint32(152).bool(message.isConfirmTournamentResult); + } + if (message.isTournamentEntry === true) { + writer.uint32(160).bool(message.isTournamentEntry); + } + if (message.resultList !== undefined) { + TournamentResultList.encode( + message.resultList, + writer.uint32(170).fork() + ).ldelim(); + } + if (message.hasCommendationStarted === true) { + writer.uint32(176).bool(message.hasCommendationStarted); + } + if (message.isCommendationRankAppeared === true) { + writer.uint32(184).bool(message.isCommendationRankAppeared); + } + if (message.isCommendationEnded === true) { + writer.uint32(192).bool(message.isCommendationEnded); + } + if (message.isNextRank === true) { + writer.uint32(200).bool(message.isNextRank); + } + if (message.commendationPage !== 0) { + writer.uint32(208).uint32(message.commendationPage); + } + if (message.showCommendationAgain === true) { + writer.uint32(216).bool(message.showCommendationAgain); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Tournament { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTournament(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.isEnableTournament = reader.bool(); + break; + case 2: + message.isClearTournament = reader.bool(); + break; + case 3: + message.isEntryPlayerOnly = reader.bool(); + break; + case 4: + message.carList = TournamentCarList.decode(reader, reader.uint32()); + break; + case 5: + message.raceDataList = TournamentRaceDataList.decode( + reader, + reader.uint32() + ); + break; + case 6: + message.isTournamentOn = reader.bool(); + break; + case 7: + message.holdYear = reader.uint32(); + break; + case 8: + message.holdMonth = reader.uint32(); + break; + case 9: + message.holdDay = reader.uint32(); + break; + case 10: + message.entryHour = reader.uint32(); + break; + case 11: + message.entryMinute = reader.uint32(); + break; + case 12: + message.tournamentStartHour = reader.uint32(); + break; + case 13: + message.tournamentStartMinute = reader.uint32(); + break; + case 14: + message.competitionNum = reader.uint32(); + break; + case 15: + message.participantNum = reader.uint32(); + break; + case 16: + message.surviverNumOfFirstRace = reader.uint32(); + break; + case 17: + message.nowRound = reader.uint32(); + break; + case 18: + message.playingGameNumber = reader.sint32(); + break; + case 19: + message.isConfirmTournamentResult = reader.bool(); + break; + case 20: + message.isTournamentEntry = reader.bool(); + break; + case 21: + message.resultList = TournamentResultList.decode( + reader, + reader.uint32() + ); + break; + case 22: + message.hasCommendationStarted = reader.bool(); + break; + case 23: + message.isCommendationRankAppeared = reader.bool(); + break; + case 24: + message.isCommendationEnded = reader.bool(); + break; + case 25: + message.isNextRank = reader.bool(); + break; + case 26: + message.commendationPage = reader.uint32(); + break; + case 27: + message.showCommendationAgain = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Tournament { + return { + isEnableTournament: isSet(object.isEnableTournament) + ? Boolean(object.isEnableTournament) + : false, + isClearTournament: isSet(object.isClearTournament) + ? Boolean(object.isClearTournament) + : false, + isEntryPlayerOnly: isSet(object.isEntryPlayerOnly) + ? Boolean(object.isEntryPlayerOnly) + : false, + carList: isSet(object.carList) + ? TournamentCarList.fromJSON(object.carList) + : undefined, + raceDataList: isSet(object.raceDataList) + ? TournamentRaceDataList.fromJSON(object.raceDataList) + : undefined, + isTournamentOn: isSet(object.isTournamentOn) + ? Boolean(object.isTournamentOn) + : false, + holdYear: isSet(object.holdYear) ? Number(object.holdYear) : 0, + holdMonth: isSet(object.holdMonth) ? Number(object.holdMonth) : 0, + holdDay: isSet(object.holdDay) ? Number(object.holdDay) : 0, + entryHour: isSet(object.entryHour) ? Number(object.entryHour) : 0, + entryMinute: isSet(object.entryMinute) ? Number(object.entryMinute) : 0, + tournamentStartHour: isSet(object.tournamentStartHour) + ? Number(object.tournamentStartHour) + : 0, + tournamentStartMinute: isSet(object.tournamentStartMinute) + ? Number(object.tournamentStartMinute) + : 0, + competitionNum: isSet(object.competitionNum) + ? Number(object.competitionNum) + : 0, + participantNum: isSet(object.participantNum) + ? Number(object.participantNum) + : 0, + surviverNumOfFirstRace: isSet(object.surviverNumOfFirstRace) + ? Number(object.surviverNumOfFirstRace) + : 0, + nowRound: isSet(object.nowRound) ? Number(object.nowRound) : 0, + playingGameNumber: isSet(object.playingGameNumber) + ? Number(object.playingGameNumber) + : 0, + isConfirmTournamentResult: isSet(object.isConfirmTournamentResult) + ? Boolean(object.isConfirmTournamentResult) + : false, + isTournamentEntry: isSet(object.isTournamentEntry) + ? Boolean(object.isTournamentEntry) + : false, + resultList: isSet(object.resultList) + ? TournamentResultList.fromJSON(object.resultList) + : undefined, + hasCommendationStarted: isSet(object.hasCommendationStarted) + ? Boolean(object.hasCommendationStarted) + : false, + isCommendationRankAppeared: isSet(object.isCommendationRankAppeared) + ? Boolean(object.isCommendationRankAppeared) + : false, + isCommendationEnded: isSet(object.isCommendationEnded) + ? Boolean(object.isCommendationEnded) + : false, + isNextRank: isSet(object.isNextRank) ? Boolean(object.isNextRank) : false, + commendationPage: isSet(object.commendationPage) + ? Number(object.commendationPage) + : 0, + showCommendationAgain: isSet(object.showCommendationAgain) + ? Boolean(object.showCommendationAgain) + : false, + }; + }, + + toJSON(message: Tournament): unknown { + const obj: any = {}; + message.isEnableTournament !== undefined && + (obj.isEnableTournament = message.isEnableTournament); + message.isClearTournament !== undefined && + (obj.isClearTournament = message.isClearTournament); + message.isEntryPlayerOnly !== undefined && + (obj.isEntryPlayerOnly = message.isEntryPlayerOnly); + message.carList !== undefined && + (obj.carList = message.carList + ? TournamentCarList.toJSON(message.carList) + : undefined); + message.raceDataList !== undefined && + (obj.raceDataList = message.raceDataList + ? TournamentRaceDataList.toJSON(message.raceDataList) + : undefined); + message.isTournamentOn !== undefined && + (obj.isTournamentOn = message.isTournamentOn); + message.holdYear !== undefined && + (obj.holdYear = Math.round(message.holdYear)); + message.holdMonth !== undefined && + (obj.holdMonth = Math.round(message.holdMonth)); + message.holdDay !== undefined && + (obj.holdDay = Math.round(message.holdDay)); + message.entryHour !== undefined && + (obj.entryHour = Math.round(message.entryHour)); + message.entryMinute !== undefined && + (obj.entryMinute = Math.round(message.entryMinute)); + message.tournamentStartHour !== undefined && + (obj.tournamentStartHour = Math.round(message.tournamentStartHour)); + message.tournamentStartMinute !== undefined && + (obj.tournamentStartMinute = Math.round(message.tournamentStartMinute)); + message.competitionNum !== undefined && + (obj.competitionNum = Math.round(message.competitionNum)); + message.participantNum !== undefined && + (obj.participantNum = Math.round(message.participantNum)); + message.surviverNumOfFirstRace !== undefined && + (obj.surviverNumOfFirstRace = Math.round(message.surviverNumOfFirstRace)); + message.nowRound !== undefined && + (obj.nowRound = Math.round(message.nowRound)); + message.playingGameNumber !== undefined && + (obj.playingGameNumber = Math.round(message.playingGameNumber)); + message.isConfirmTournamentResult !== undefined && + (obj.isConfirmTournamentResult = message.isConfirmTournamentResult); + message.isTournamentEntry !== undefined && + (obj.isTournamentEntry = message.isTournamentEntry); + message.resultList !== undefined && + (obj.resultList = message.resultList + ? TournamentResultList.toJSON(message.resultList) + : undefined); + message.hasCommendationStarted !== undefined && + (obj.hasCommendationStarted = message.hasCommendationStarted); + message.isCommendationRankAppeared !== undefined && + (obj.isCommendationRankAppeared = message.isCommendationRankAppeared); + message.isCommendationEnded !== undefined && + (obj.isCommendationEnded = message.isCommendationEnded); + message.isNextRank !== undefined && (obj.isNextRank = message.isNextRank); + message.commendationPage !== undefined && + (obj.commendationPage = Math.round(message.commendationPage)); + message.showCommendationAgain !== undefined && + (obj.showCommendationAgain = message.showCommendationAgain); + return obj; + }, + + fromPartial, I>>( + object: I + ): Tournament { + const message = createBaseTournament(); + message.isEnableTournament = object.isEnableTournament ?? false; + message.isClearTournament = object.isClearTournament ?? false; + message.isEntryPlayerOnly = object.isEntryPlayerOnly ?? false; + message.carList = + object.carList !== undefined && object.carList !== null + ? TournamentCarList.fromPartial(object.carList) + : undefined; + message.raceDataList = + object.raceDataList !== undefined && object.raceDataList !== null + ? TournamentRaceDataList.fromPartial(object.raceDataList) + : undefined; + message.isTournamentOn = object.isTournamentOn ?? false; + message.holdYear = object.holdYear ?? 0; + message.holdMonth = object.holdMonth ?? 0; + message.holdDay = object.holdDay ?? 0; + message.entryHour = object.entryHour ?? 0; + message.entryMinute = object.entryMinute ?? 0; + message.tournamentStartHour = object.tournamentStartHour ?? 0; + message.tournamentStartMinute = object.tournamentStartMinute ?? 0; + message.competitionNum = object.competitionNum ?? 0; + message.participantNum = object.participantNum ?? 0; + message.surviverNumOfFirstRace = object.surviverNumOfFirstRace ?? 0; + message.nowRound = object.nowRound ?? 0; + message.playingGameNumber = object.playingGameNumber ?? 0; + message.isConfirmTournamentResult = + object.isConfirmTournamentResult ?? false; + message.isTournamentEntry = object.isTournamentEntry ?? false; + message.resultList = + object.resultList !== undefined && object.resultList !== null + ? TournamentResultList.fromPartial(object.resultList) + : undefined; + message.hasCommendationStarted = object.hasCommendationStarted ?? false; + message.isCommendationRankAppeared = + object.isCommendationRankAppeared ?? false; + message.isCommendationEnded = object.isCommendationEnded ?? false; + message.isNextRank = object.isNextRank ?? false; + message.commendationPage = object.commendationPage ?? 0; + message.showCommendationAgain = object.showCommendationAgain ?? false; + return message; + }, +}; + +function createBaseMessage(): Message { + return { + racePacket: new Uint8Array(), + raceCar: new Uint8Array(), + course: undefined, + vsOk: 0, + heartBeat: undefined, + batchSettingState: 0, + driveCabinetState: undefined, + batchSetting: undefined, + information: undefined, + featureVersion: undefined, + tournament: undefined, + }; +} + +export const Message = { + encode( + message: Message, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.racePacket.length !== 0) { + writer.uint32(10).bytes(message.racePacket); + } + if (message.raceCar.length !== 0) { + writer.uint32(18).bytes(message.raceCar); + } + if (message.course !== undefined) { + Course.encode(message.course, writer.uint32(26).fork()).ldelim(); + } + if (message.vsOk !== 0) { + writer.uint32(32).int32(message.vsOk); + } + if (message.heartBeat !== undefined) { + HeartBeat.encode(message.heartBeat, writer.uint32(42).fork()).ldelim(); + } + if (message.batchSettingState !== 0) { + writer.uint32(48).int32(message.batchSettingState); + } + if (message.driveCabinetState !== undefined) { + DriveCabinetState.encode( + message.driveCabinetState, + writer.uint32(58).fork() + ).ldelim(); + } + if (message.batchSetting !== undefined) { + BatchSetting.encode( + message.batchSetting, + writer.uint32(66).fork() + ).ldelim(); + } + if (message.information !== undefined) { + Information.encode( + message.information, + writer.uint32(74).fork() + ).ldelim(); + } + if (message.featureVersion !== undefined) { + GameFeatureVersion.encode( + message.featureVersion, + writer.uint32(82).fork() + ).ldelim(); + } + if (message.tournament !== undefined) { + Tournament.encode(message.tournament, writer.uint32(90).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Message { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMessage(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.racePacket = reader.bytes(); + break; + case 2: + message.raceCar = reader.bytes(); + break; + case 3: + message.course = Course.decode(reader, reader.uint32()); + break; + case 4: + message.vsOk = reader.int32(); + break; + case 5: + message.heartBeat = HeartBeat.decode(reader, reader.uint32()); + break; + case 6: + message.batchSettingState = reader.int32(); + break; + case 7: + message.driveCabinetState = DriveCabinetState.decode( + reader, + reader.uint32() + ); + break; + case 8: + message.batchSetting = BatchSetting.decode(reader, reader.uint32()); + break; + case 9: + message.information = Information.decode(reader, reader.uint32()); + break; + case 10: + message.featureVersion = GameFeatureVersion.decode( + reader, + reader.uint32() + ); + break; + case 11: + message.tournament = Tournament.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Message { + return { + racePacket: isSet(object.racePacket) + ? bytesFromBase64(object.racePacket) + : new Uint8Array(), + raceCar: isSet(object.raceCar) + ? bytesFromBase64(object.raceCar) + : new Uint8Array(), + course: isSet(object.course) ? Course.fromJSON(object.course) : undefined, + vsOk: isSet(object.vsOk) ? Number(object.vsOk) : 0, + heartBeat: isSet(object.heartBeat) + ? HeartBeat.fromJSON(object.heartBeat) + : undefined, + batchSettingState: isSet(object.batchSettingState) + ? Number(object.batchSettingState) + : 0, + driveCabinetState: isSet(object.driveCabinetState) + ? DriveCabinetState.fromJSON(object.driveCabinetState) + : undefined, + batchSetting: isSet(object.batchSetting) + ? BatchSetting.fromJSON(object.batchSetting) + : undefined, + information: isSet(object.information) + ? Information.fromJSON(object.information) + : undefined, + featureVersion: isSet(object.featureVersion) + ? GameFeatureVersion.fromJSON(object.featureVersion) + : undefined, + tournament: isSet(object.tournament) + ? Tournament.fromJSON(object.tournament) + : undefined, + }; + }, + + toJSON(message: Message): unknown { + const obj: any = {}; + message.racePacket !== undefined && + (obj.racePacket = base64FromBytes( + message.racePacket !== undefined ? message.racePacket : new Uint8Array() + )); + message.raceCar !== undefined && + (obj.raceCar = base64FromBytes( + message.raceCar !== undefined ? message.raceCar : new Uint8Array() + )); + message.course !== undefined && + (obj.course = message.course ? Course.toJSON(message.course) : undefined); + message.vsOk !== undefined && (obj.vsOk = Math.round(message.vsOk)); + message.heartBeat !== undefined && + (obj.heartBeat = message.heartBeat + ? HeartBeat.toJSON(message.heartBeat) + : undefined); + message.batchSettingState !== undefined && + (obj.batchSettingState = Math.round(message.batchSettingState)); + message.driveCabinetState !== undefined && + (obj.driveCabinetState = message.driveCabinetState + ? DriveCabinetState.toJSON(message.driveCabinetState) + : undefined); + message.batchSetting !== undefined && + (obj.batchSetting = message.batchSetting + ? BatchSetting.toJSON(message.batchSetting) + : undefined); + message.information !== undefined && + (obj.information = message.information + ? Information.toJSON(message.information) + : undefined); + message.featureVersion !== undefined && + (obj.featureVersion = message.featureVersion + ? GameFeatureVersion.toJSON(message.featureVersion) + : undefined); + message.tournament !== undefined && + (obj.tournament = message.tournament + ? Tournament.toJSON(message.tournament) + : undefined); + return obj; + }, + + fromPartial, I>>(object: I): Message { + const message = createBaseMessage(); + message.racePacket = object.racePacket ?? new Uint8Array(); + message.raceCar = object.raceCar ?? new Uint8Array(); + message.course = + object.course !== undefined && object.course !== null + ? Course.fromPartial(object.course) + : undefined; + message.vsOk = object.vsOk ?? 0; + message.heartBeat = + object.heartBeat !== undefined && object.heartBeat !== null + ? HeartBeat.fromPartial(object.heartBeat) + : undefined; + message.batchSettingState = object.batchSettingState ?? 0; + message.driveCabinetState = + object.driveCabinetState !== undefined && + object.driveCabinetState !== null + ? DriveCabinetState.fromPartial(object.driveCabinetState) + : undefined; + message.batchSetting = + object.batchSetting !== undefined && object.batchSetting !== null + ? BatchSetting.fromPartial(object.batchSetting) + : undefined; + message.information = + object.information !== undefined && object.information !== null + ? Information.fromPartial(object.information) + : undefined; + message.featureVersion = + object.featureVersion !== undefined && object.featureVersion !== null + ? GameFeatureVersion.fromPartial(object.featureVersion) + : undefined; + message.tournament = + object.tournament !== undefined && object.tournament !== null + ? Tournament.fromPartial(object.tournament) + : undefined; + return message; + }, +}; + +declare var self: any | undefined; +declare var window: any | undefined; +declare var global: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + +const atob: (b64: string) => string = + globalThis.atob || + ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary")); +function bytesFromBase64(b64: string): Uint8Array { + const bin = atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; +} + +const btoa: (bin: string) => string = + globalThis.btoa || + ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64")); +function base64FromBytes(arr: Uint8Array): string { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(String.fromCharCode(byte)); + }); + return btoa(bin.join("")); +} + +type Builtin = + | Date + | Function + | Uint8Array + | string + | number + | boolean + | undefined; + +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +type KeysOfUnion = T extends T ? keyof T : never; +export type Exact = P extends Builtin + ? P + : P & { [K in keyof P]: Exact } & Record< + Exclude>, + never + >; + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} diff --git a/proto_src/proto/game.ts b/proto_src/proto/game.ts new file mode 100644 index 0000000..7d42682 --- /dev/null +++ b/proto_src/proto/game.ts @@ -0,0 +1,1133 @@ +/* eslint-disable */ +export const protobufPackage = "game"; + +export enum gidArea { + GID_AREA_TOKYO = 0, + GID_AREA_HAKONE = 1, + GID_AREA_NAGOYA = 2, + GID_AREA_OSAKA = 3, + GID_AREA_FUKUOKA = 4, + GID_AREA_SUBTOKYO_3_4 = 5, + GID_AREA_SUBTOKYO_5 = 6, + GID_AREA_TURNPIKE = 7, + GID_AREA_KOBE = 8, + GID_AREA_HIROSHIMA = 9, + GID_AREA_STORY = 10, + UNRECOGNIZED = -1, +} + +export function gidAreaFromJSON(object: any): gidArea { + switch (object) { + case 0: + case "GID_AREA_TOKYO": + return gidArea.GID_AREA_TOKYO; + case 1: + case "GID_AREA_HAKONE": + return gidArea.GID_AREA_HAKONE; + case 2: + case "GID_AREA_NAGOYA": + return gidArea.GID_AREA_NAGOYA; + case 3: + case "GID_AREA_OSAKA": + return gidArea.GID_AREA_OSAKA; + case 4: + case "GID_AREA_FUKUOKA": + return gidArea.GID_AREA_FUKUOKA; + case 5: + case "GID_AREA_SUBTOKYO_3_4": + return gidArea.GID_AREA_SUBTOKYO_3_4; + case 6: + case "GID_AREA_SUBTOKYO_5": + return gidArea.GID_AREA_SUBTOKYO_5; + case 7: + case "GID_AREA_TURNPIKE": + return gidArea.GID_AREA_TURNPIKE; + case 8: + case "GID_AREA_KOBE": + return gidArea.GID_AREA_KOBE; + case 9: + case "GID_AREA_HIROSHIMA": + return gidArea.GID_AREA_HIROSHIMA; + case 10: + case "GID_AREA_STORY": + return gidArea.GID_AREA_STORY; + case -1: + case "UNRECOGNIZED": + default: + return gidArea.UNRECOGNIZED; + } +} + +export function gidAreaToJSON(object: gidArea): string { + switch (object) { + case gidArea.GID_AREA_TOKYO: + return "GID_AREA_TOKYO"; + case gidArea.GID_AREA_HAKONE: + return "GID_AREA_HAKONE"; + case gidArea.GID_AREA_NAGOYA: + return "GID_AREA_NAGOYA"; + case gidArea.GID_AREA_OSAKA: + return "GID_AREA_OSAKA"; + case gidArea.GID_AREA_FUKUOKA: + return "GID_AREA_FUKUOKA"; + case gidArea.GID_AREA_SUBTOKYO_3_4: + return "GID_AREA_SUBTOKYO_3_4"; + case gidArea.GID_AREA_SUBTOKYO_5: + return "GID_AREA_SUBTOKYO_5"; + case gidArea.GID_AREA_TURNPIKE: + return "GID_AREA_TURNPIKE"; + case gidArea.GID_AREA_KOBE: + return "GID_AREA_KOBE"; + case gidArea.GID_AREA_HIROSHIMA: + return "GID_AREA_HIROSHIMA"; + case gidArea.GID_AREA_STORY: + return "GID_AREA_STORY"; + case gidArea.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum gidTacourse { + GID_TACOURSE_C1IN = 0, + GID_TACOURSE_C1OUT = 1, + GID_TACOURSE_RINGLEFT = 2, + GID_TACOURSE_RINGRIGHT = 3, + GID_TACOURSE_SUBTOKYO_3_4 = 4, + GID_TACOURSE_SUBTOKYO_5 = 5, + GID_TACOURSE_WANGANEAST = 6, + GID_TACOURSE_WANGANWEST = 7, + GID_TACOURSE_K1_DOWN = 8, + GID_TACOURSE_K1_UP = 9, + GID_TACOURSE_YAESUIN = 10, + GID_TACOURSE_YAESUOUT = 11, + GID_TACOURSE_YOKOHAMAIN = 12, + GID_TACOURSE_YOKOHAMAOUT = 13, + GID_TACOURSE_NAGOYA = 14, + GID_TACOURSE_OSAKA = 15, + GID_TACOURSE_KOBE = 16, + GID_TACOURSE_FUKUOKA = 17, + GID_TACOURSE_HAKONEFOR = 18, + GID_TACOURSE_HAKONEBACK = 19, + GID_TACOURSE_TURNPIKE_UP = 20, + GID_TACOURSE_TURNPIKE_DOWN = 21, + GID_TACOURSE_TOKYOALL = 22, + GID_TACOURSE_KANAGAWAALL = 23, + GID_TACOURSE_HIROSHIMA = 24, + UNRECOGNIZED = -1, +} + +export function gidTacourseFromJSON(object: any): gidTacourse { + switch (object) { + case 0: + case "GID_TACOURSE_C1IN": + return gidTacourse.GID_TACOURSE_C1IN; + case 1: + case "GID_TACOURSE_C1OUT": + return gidTacourse.GID_TACOURSE_C1OUT; + case 2: + case "GID_TACOURSE_RINGLEFT": + return gidTacourse.GID_TACOURSE_RINGLEFT; + case 3: + case "GID_TACOURSE_RINGRIGHT": + return gidTacourse.GID_TACOURSE_RINGRIGHT; + case 4: + case "GID_TACOURSE_SUBTOKYO_3_4": + return gidTacourse.GID_TACOURSE_SUBTOKYO_3_4; + case 5: + case "GID_TACOURSE_SUBTOKYO_5": + return gidTacourse.GID_TACOURSE_SUBTOKYO_5; + case 6: + case "GID_TACOURSE_WANGANEAST": + return gidTacourse.GID_TACOURSE_WANGANEAST; + case 7: + case "GID_TACOURSE_WANGANWEST": + return gidTacourse.GID_TACOURSE_WANGANWEST; + case 8: + case "GID_TACOURSE_K1_DOWN": + return gidTacourse.GID_TACOURSE_K1_DOWN; + case 9: + case "GID_TACOURSE_K1_UP": + return gidTacourse.GID_TACOURSE_K1_UP; + case 10: + case "GID_TACOURSE_YAESUIN": + return gidTacourse.GID_TACOURSE_YAESUIN; + case 11: + case "GID_TACOURSE_YAESUOUT": + return gidTacourse.GID_TACOURSE_YAESUOUT; + case 12: + case "GID_TACOURSE_YOKOHAMAIN": + return gidTacourse.GID_TACOURSE_YOKOHAMAIN; + case 13: + case "GID_TACOURSE_YOKOHAMAOUT": + return gidTacourse.GID_TACOURSE_YOKOHAMAOUT; + case 14: + case "GID_TACOURSE_NAGOYA": + return gidTacourse.GID_TACOURSE_NAGOYA; + case 15: + case "GID_TACOURSE_OSAKA": + return gidTacourse.GID_TACOURSE_OSAKA; + case 16: + case "GID_TACOURSE_KOBE": + return gidTacourse.GID_TACOURSE_KOBE; + case 17: + case "GID_TACOURSE_FUKUOKA": + return gidTacourse.GID_TACOURSE_FUKUOKA; + case 18: + case "GID_TACOURSE_HAKONEFOR": + return gidTacourse.GID_TACOURSE_HAKONEFOR; + case 19: + case "GID_TACOURSE_HAKONEBACK": + return gidTacourse.GID_TACOURSE_HAKONEBACK; + case 20: + case "GID_TACOURSE_TURNPIKE_UP": + return gidTacourse.GID_TACOURSE_TURNPIKE_UP; + case 21: + case "GID_TACOURSE_TURNPIKE_DOWN": + return gidTacourse.GID_TACOURSE_TURNPIKE_DOWN; + case 22: + case "GID_TACOURSE_TOKYOALL": + return gidTacourse.GID_TACOURSE_TOKYOALL; + case 23: + case "GID_TACOURSE_KANAGAWAALL": + return gidTacourse.GID_TACOURSE_KANAGAWAALL; + case 24: + case "GID_TACOURSE_HIROSHIMA": + return gidTacourse.GID_TACOURSE_HIROSHIMA; + case -1: + case "UNRECOGNIZED": + default: + return gidTacourse.UNRECOGNIZED; + } +} + +export function gidTacourseToJSON(object: gidTacourse): string { + switch (object) { + case gidTacourse.GID_TACOURSE_C1IN: + return "GID_TACOURSE_C1IN"; + case gidTacourse.GID_TACOURSE_C1OUT: + return "GID_TACOURSE_C1OUT"; + case gidTacourse.GID_TACOURSE_RINGLEFT: + return "GID_TACOURSE_RINGLEFT"; + case gidTacourse.GID_TACOURSE_RINGRIGHT: + return "GID_TACOURSE_RINGRIGHT"; + case gidTacourse.GID_TACOURSE_SUBTOKYO_3_4: + return "GID_TACOURSE_SUBTOKYO_3_4"; + case gidTacourse.GID_TACOURSE_SUBTOKYO_5: + return "GID_TACOURSE_SUBTOKYO_5"; + case gidTacourse.GID_TACOURSE_WANGANEAST: + return "GID_TACOURSE_WANGANEAST"; + case gidTacourse.GID_TACOURSE_WANGANWEST: + return "GID_TACOURSE_WANGANWEST"; + case gidTacourse.GID_TACOURSE_K1_DOWN: + return "GID_TACOURSE_K1_DOWN"; + case gidTacourse.GID_TACOURSE_K1_UP: + return "GID_TACOURSE_K1_UP"; + case gidTacourse.GID_TACOURSE_YAESUIN: + return "GID_TACOURSE_YAESUIN"; + case gidTacourse.GID_TACOURSE_YAESUOUT: + return "GID_TACOURSE_YAESUOUT"; + case gidTacourse.GID_TACOURSE_YOKOHAMAIN: + return "GID_TACOURSE_YOKOHAMAIN"; + case gidTacourse.GID_TACOURSE_YOKOHAMAOUT: + return "GID_TACOURSE_YOKOHAMAOUT"; + case gidTacourse.GID_TACOURSE_NAGOYA: + return "GID_TACOURSE_NAGOYA"; + case gidTacourse.GID_TACOURSE_OSAKA: + return "GID_TACOURSE_OSAKA"; + case gidTacourse.GID_TACOURSE_KOBE: + return "GID_TACOURSE_KOBE"; + case gidTacourse.GID_TACOURSE_FUKUOKA: + return "GID_TACOURSE_FUKUOKA"; + case gidTacourse.GID_TACOURSE_HAKONEFOR: + return "GID_TACOURSE_HAKONEFOR"; + case gidTacourse.GID_TACOURSE_HAKONEBACK: + return "GID_TACOURSE_HAKONEBACK"; + case gidTacourse.GID_TACOURSE_TURNPIKE_UP: + return "GID_TACOURSE_TURNPIKE_UP"; + case gidTacourse.GID_TACOURSE_TURNPIKE_DOWN: + return "GID_TACOURSE_TURNPIKE_DOWN"; + case gidTacourse.GID_TACOURSE_TOKYOALL: + return "GID_TACOURSE_TOKYOALL"; + case gidTacourse.GID_TACOURSE_KANAGAWAALL: + return "GID_TACOURSE_KANAGAWAALL"; + case gidTacourse.GID_TACOURSE_HIROSHIMA: + return "GID_TACOURSE_HIROSHIMA"; + case gidTacourse.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum gidRunarea { + GID_RUNAREA_C1 = 0, + GID_RUNAREA_RING = 1, + GID_RUNAREA_SUBTOKYO_3_4 = 2, + GID_RUNAREA_SUBTOKYO_5 = 3, + GID_RUNAREA_WANGAN = 4, + GID_RUNAREA_K1 = 5, + GID_RUNAREA_YAESU = 6, + GID_RUNAREA_YOKOHAMA = 7, + GID_RUNAREA_NAGOYA = 8, + GID_RUNAREA_OSAKA = 9, + GID_RUNAREA_KOBE = 10, + GID_RUNAREA_FUKUOKA = 11, + GID_RUNAREA_HAKONE = 12, + GID_RUNAREA_TURNPIKE = 13, + GID_RUNAREA_DUMMY1 = 14, + GID_RUNAREA_DUMMY2 = 15, + GID_RUNAREA_DUMMY3 = 16, + GID_RUNAREA_C1_CLOSED = 17, + GID_RUNAREA_HIROSHIMA = 18, + UNRECOGNIZED = -1, +} + +export function gidRunareaFromJSON(object: any): gidRunarea { + switch (object) { + case 0: + case "GID_RUNAREA_C1": + return gidRunarea.GID_RUNAREA_C1; + case 1: + case "GID_RUNAREA_RING": + return gidRunarea.GID_RUNAREA_RING; + case 2: + case "GID_RUNAREA_SUBTOKYO_3_4": + return gidRunarea.GID_RUNAREA_SUBTOKYO_3_4; + case 3: + case "GID_RUNAREA_SUBTOKYO_5": + return gidRunarea.GID_RUNAREA_SUBTOKYO_5; + case 4: + case "GID_RUNAREA_WANGAN": + return gidRunarea.GID_RUNAREA_WANGAN; + case 5: + case "GID_RUNAREA_K1": + return gidRunarea.GID_RUNAREA_K1; + case 6: + case "GID_RUNAREA_YAESU": + return gidRunarea.GID_RUNAREA_YAESU; + case 7: + case "GID_RUNAREA_YOKOHAMA": + return gidRunarea.GID_RUNAREA_YOKOHAMA; + case 8: + case "GID_RUNAREA_NAGOYA": + return gidRunarea.GID_RUNAREA_NAGOYA; + case 9: + case "GID_RUNAREA_OSAKA": + return gidRunarea.GID_RUNAREA_OSAKA; + case 10: + case "GID_RUNAREA_KOBE": + return gidRunarea.GID_RUNAREA_KOBE; + case 11: + case "GID_RUNAREA_FUKUOKA": + return gidRunarea.GID_RUNAREA_FUKUOKA; + case 12: + case "GID_RUNAREA_HAKONE": + return gidRunarea.GID_RUNAREA_HAKONE; + case 13: + case "GID_RUNAREA_TURNPIKE": + return gidRunarea.GID_RUNAREA_TURNPIKE; + case 14: + case "GID_RUNAREA_DUMMY1": + return gidRunarea.GID_RUNAREA_DUMMY1; + case 15: + case "GID_RUNAREA_DUMMY2": + return gidRunarea.GID_RUNAREA_DUMMY2; + case 16: + case "GID_RUNAREA_DUMMY3": + return gidRunarea.GID_RUNAREA_DUMMY3; + case 17: + case "GID_RUNAREA_C1_CLOSED": + return gidRunarea.GID_RUNAREA_C1_CLOSED; + case 18: + case "GID_RUNAREA_HIROSHIMA": + return gidRunarea.GID_RUNAREA_HIROSHIMA; + case -1: + case "UNRECOGNIZED": + default: + return gidRunarea.UNRECOGNIZED; + } +} + +export function gidRunareaToJSON(object: gidRunarea): string { + switch (object) { + case gidRunarea.GID_RUNAREA_C1: + return "GID_RUNAREA_C1"; + case gidRunarea.GID_RUNAREA_RING: + return "GID_RUNAREA_RING"; + case gidRunarea.GID_RUNAREA_SUBTOKYO_3_4: + return "GID_RUNAREA_SUBTOKYO_3_4"; + case gidRunarea.GID_RUNAREA_SUBTOKYO_5: + return "GID_RUNAREA_SUBTOKYO_5"; + case gidRunarea.GID_RUNAREA_WANGAN: + return "GID_RUNAREA_WANGAN"; + case gidRunarea.GID_RUNAREA_K1: + return "GID_RUNAREA_K1"; + case gidRunarea.GID_RUNAREA_YAESU: + return "GID_RUNAREA_YAESU"; + case gidRunarea.GID_RUNAREA_YOKOHAMA: + return "GID_RUNAREA_YOKOHAMA"; + case gidRunarea.GID_RUNAREA_NAGOYA: + return "GID_RUNAREA_NAGOYA"; + case gidRunarea.GID_RUNAREA_OSAKA: + return "GID_RUNAREA_OSAKA"; + case gidRunarea.GID_RUNAREA_KOBE: + return "GID_RUNAREA_KOBE"; + case gidRunarea.GID_RUNAREA_FUKUOKA: + return "GID_RUNAREA_FUKUOKA"; + case gidRunarea.GID_RUNAREA_HAKONE: + return "GID_RUNAREA_HAKONE"; + case gidRunarea.GID_RUNAREA_TURNPIKE: + return "GID_RUNAREA_TURNPIKE"; + case gidRunarea.GID_RUNAREA_DUMMY1: + return "GID_RUNAREA_DUMMY1"; + case gidRunarea.GID_RUNAREA_DUMMY2: + return "GID_RUNAREA_DUMMY2"; + case gidRunarea.GID_RUNAREA_DUMMY3: + return "GID_RUNAREA_DUMMY3"; + case gidRunarea.GID_RUNAREA_C1_CLOSED: + return "GID_RUNAREA_C1_CLOSED"; + case gidRunarea.GID_RUNAREA_HIROSHIMA: + return "GID_RUNAREA_HIROSHIMA"; + case gidRunarea.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum gidRamp { + GID_RAMP_C1_IN_KANDABASHI = 0, + GID_RAMP_C1_IN_SHIODOME = 1, + GID_RAMP_C1_OUT_KANDABASHI = 2, + GID_RAMP_C1_OUT_SHIBA = 3, + GID_RAMP_RING_LEFT_ARIAKE = 4, + GID_RAMP_RING_RIGHT_KIBA = 5, + GID_RAMP_SUBTOKYO_SHIBUYA = 6, + GID_RAMP_SUBTOKYO_GAIEN = 7, + GID_RAMP_SUBTOKYO_DAIKANCHOU = 8, + GID_RAMP_SUBTOKYO_SHINJUKU = 9, + GID_RAMP_WANGAN_EAST_AIRPORT = 10, + GID_RAMP_WANGAN_EAST_DAIKOKU = 11, + GID_RAMP_WANGAN_WEST_RINKAI = 12, + GID_RAMP_WANGAN_WEST_AIRPORT = 13, + GID_RAMP_K1_DOWN_SHIBAURA = 14, + GID_RAMP_K1_DOWN_HANEDA = 15, + GID_RAMP_K1_UP_HANEDA = 16, + GID_RAMP_K1_UP_SHIOIRI = 17, + GID_RAMP_YAESU_SHIODOME = 18, + GID_RAMP_YAESU_KYOBASHI = 19, + GID_RAMP_YAESU_KANDABASHI = 20, + GID_RAMP_MINATOMIRAI_IN_HIGASHIKANAGAWA = 21, + GID_RAMP_MINATOMIRAI_IN_MINATOMIRAI = 22, + GID_RAMP_MINATOMIRAI_OUT_SHINYAMASHITA = 23, + GID_RAMP_MINATOMIRAI_OUT_MINATOMIRAI = 24, + GID_RAMP_NAGOYA_MARUNOUCHI = 25, + GID_RAMP_OOSAKA_DOUTONBORI = 26, + GID_RAMP_KOBE_SHINKOUCHOU = 27, + GID_RAMP_KOBE_NADAOOHASHI = 28, + GID_RAMP_FUKUOKA_WEST_MEIHAMA = 29, + GID_RAMP_FUKUOKA_WEST_HAKATA = 30, + GID_RAMP_FUKUOKA_EAST_NISHI = 31, + GID_RAMP_FUKUOKA_EAST_HANDOUBASHI = 32, + GID_RAMP_HAKONE_FOR = 33, + GID_RAMP_HAKONE_BACK = 34, + GID_RAMP_TURNPIKE_UP = 35, + GID_RAMP_TURNPIKE_DOWN = 36, + GID_RAMP_HIROSHIMA_SHINONOME = 37, + GID_RAMP_HIROSHIMA_UJINA = 38, + UNRECOGNIZED = -1, +} + +export function gidRampFromJSON(object: any): gidRamp { + switch (object) { + case 0: + case "GID_RAMP_C1_IN_KANDABASHI": + return gidRamp.GID_RAMP_C1_IN_KANDABASHI; + case 1: + case "GID_RAMP_C1_IN_SHIODOME": + return gidRamp.GID_RAMP_C1_IN_SHIODOME; + case 2: + case "GID_RAMP_C1_OUT_KANDABASHI": + return gidRamp.GID_RAMP_C1_OUT_KANDABASHI; + case 3: + case "GID_RAMP_C1_OUT_SHIBA": + return gidRamp.GID_RAMP_C1_OUT_SHIBA; + case 4: + case "GID_RAMP_RING_LEFT_ARIAKE": + return gidRamp.GID_RAMP_RING_LEFT_ARIAKE; + case 5: + case "GID_RAMP_RING_RIGHT_KIBA": + return gidRamp.GID_RAMP_RING_RIGHT_KIBA; + case 6: + case "GID_RAMP_SUBTOKYO_SHIBUYA": + return gidRamp.GID_RAMP_SUBTOKYO_SHIBUYA; + case 7: + case "GID_RAMP_SUBTOKYO_GAIEN": + return gidRamp.GID_RAMP_SUBTOKYO_GAIEN; + case 8: + case "GID_RAMP_SUBTOKYO_DAIKANCHOU": + return gidRamp.GID_RAMP_SUBTOKYO_DAIKANCHOU; + case 9: + case "GID_RAMP_SUBTOKYO_SHINJUKU": + return gidRamp.GID_RAMP_SUBTOKYO_SHINJUKU; + case 10: + case "GID_RAMP_WANGAN_EAST_AIRPORT": + return gidRamp.GID_RAMP_WANGAN_EAST_AIRPORT; + case 11: + case "GID_RAMP_WANGAN_EAST_DAIKOKU": + return gidRamp.GID_RAMP_WANGAN_EAST_DAIKOKU; + case 12: + case "GID_RAMP_WANGAN_WEST_RINKAI": + return gidRamp.GID_RAMP_WANGAN_WEST_RINKAI; + case 13: + case "GID_RAMP_WANGAN_WEST_AIRPORT": + return gidRamp.GID_RAMP_WANGAN_WEST_AIRPORT; + case 14: + case "GID_RAMP_K1_DOWN_SHIBAURA": + return gidRamp.GID_RAMP_K1_DOWN_SHIBAURA; + case 15: + case "GID_RAMP_K1_DOWN_HANEDA": + return gidRamp.GID_RAMP_K1_DOWN_HANEDA; + case 16: + case "GID_RAMP_K1_UP_HANEDA": + return gidRamp.GID_RAMP_K1_UP_HANEDA; + case 17: + case "GID_RAMP_K1_UP_SHIOIRI": + return gidRamp.GID_RAMP_K1_UP_SHIOIRI; + case 18: + case "GID_RAMP_YAESU_SHIODOME": + return gidRamp.GID_RAMP_YAESU_SHIODOME; + case 19: + case "GID_RAMP_YAESU_KYOBASHI": + return gidRamp.GID_RAMP_YAESU_KYOBASHI; + case 20: + case "GID_RAMP_YAESU_KANDABASHI": + return gidRamp.GID_RAMP_YAESU_KANDABASHI; + case 21: + case "GID_RAMP_MINATOMIRAI_IN_HIGASHIKANAGAWA": + return gidRamp.GID_RAMP_MINATOMIRAI_IN_HIGASHIKANAGAWA; + case 22: + case "GID_RAMP_MINATOMIRAI_IN_MINATOMIRAI": + return gidRamp.GID_RAMP_MINATOMIRAI_IN_MINATOMIRAI; + case 23: + case "GID_RAMP_MINATOMIRAI_OUT_SHINYAMASHITA": + return gidRamp.GID_RAMP_MINATOMIRAI_OUT_SHINYAMASHITA; + case 24: + case "GID_RAMP_MINATOMIRAI_OUT_MINATOMIRAI": + return gidRamp.GID_RAMP_MINATOMIRAI_OUT_MINATOMIRAI; + case 25: + case "GID_RAMP_NAGOYA_MARUNOUCHI": + return gidRamp.GID_RAMP_NAGOYA_MARUNOUCHI; + case 26: + case "GID_RAMP_OOSAKA_DOUTONBORI": + return gidRamp.GID_RAMP_OOSAKA_DOUTONBORI; + case 27: + case "GID_RAMP_KOBE_SHINKOUCHOU": + return gidRamp.GID_RAMP_KOBE_SHINKOUCHOU; + case 28: + case "GID_RAMP_KOBE_NADAOOHASHI": + return gidRamp.GID_RAMP_KOBE_NADAOOHASHI; + case 29: + case "GID_RAMP_FUKUOKA_WEST_MEIHAMA": + return gidRamp.GID_RAMP_FUKUOKA_WEST_MEIHAMA; + case 30: + case "GID_RAMP_FUKUOKA_WEST_HAKATA": + return gidRamp.GID_RAMP_FUKUOKA_WEST_HAKATA; + case 31: + case "GID_RAMP_FUKUOKA_EAST_NISHI": + return gidRamp.GID_RAMP_FUKUOKA_EAST_NISHI; + case 32: + case "GID_RAMP_FUKUOKA_EAST_HANDOUBASHI": + return gidRamp.GID_RAMP_FUKUOKA_EAST_HANDOUBASHI; + case 33: + case "GID_RAMP_HAKONE_FOR": + return gidRamp.GID_RAMP_HAKONE_FOR; + case 34: + case "GID_RAMP_HAKONE_BACK": + return gidRamp.GID_RAMP_HAKONE_BACK; + case 35: + case "GID_RAMP_TURNPIKE_UP": + return gidRamp.GID_RAMP_TURNPIKE_UP; + case 36: + case "GID_RAMP_TURNPIKE_DOWN": + return gidRamp.GID_RAMP_TURNPIKE_DOWN; + case 37: + case "GID_RAMP_HIROSHIMA_SHINONOME": + return gidRamp.GID_RAMP_HIROSHIMA_SHINONOME; + case 38: + case "GID_RAMP_HIROSHIMA_UJINA": + return gidRamp.GID_RAMP_HIROSHIMA_UJINA; + case -1: + case "UNRECOGNIZED": + default: + return gidRamp.UNRECOGNIZED; + } +} + +export function gidRampToJSON(object: gidRamp): string { + switch (object) { + case gidRamp.GID_RAMP_C1_IN_KANDABASHI: + return "GID_RAMP_C1_IN_KANDABASHI"; + case gidRamp.GID_RAMP_C1_IN_SHIODOME: + return "GID_RAMP_C1_IN_SHIODOME"; + case gidRamp.GID_RAMP_C1_OUT_KANDABASHI: + return "GID_RAMP_C1_OUT_KANDABASHI"; + case gidRamp.GID_RAMP_C1_OUT_SHIBA: + return "GID_RAMP_C1_OUT_SHIBA"; + case gidRamp.GID_RAMP_RING_LEFT_ARIAKE: + return "GID_RAMP_RING_LEFT_ARIAKE"; + case gidRamp.GID_RAMP_RING_RIGHT_KIBA: + return "GID_RAMP_RING_RIGHT_KIBA"; + case gidRamp.GID_RAMP_SUBTOKYO_SHIBUYA: + return "GID_RAMP_SUBTOKYO_SHIBUYA"; + case gidRamp.GID_RAMP_SUBTOKYO_GAIEN: + return "GID_RAMP_SUBTOKYO_GAIEN"; + case gidRamp.GID_RAMP_SUBTOKYO_DAIKANCHOU: + return "GID_RAMP_SUBTOKYO_DAIKANCHOU"; + case gidRamp.GID_RAMP_SUBTOKYO_SHINJUKU: + return "GID_RAMP_SUBTOKYO_SHINJUKU"; + case gidRamp.GID_RAMP_WANGAN_EAST_AIRPORT: + return "GID_RAMP_WANGAN_EAST_AIRPORT"; + case gidRamp.GID_RAMP_WANGAN_EAST_DAIKOKU: + return "GID_RAMP_WANGAN_EAST_DAIKOKU"; + case gidRamp.GID_RAMP_WANGAN_WEST_RINKAI: + return "GID_RAMP_WANGAN_WEST_RINKAI"; + case gidRamp.GID_RAMP_WANGAN_WEST_AIRPORT: + return "GID_RAMP_WANGAN_WEST_AIRPORT"; + case gidRamp.GID_RAMP_K1_DOWN_SHIBAURA: + return "GID_RAMP_K1_DOWN_SHIBAURA"; + case gidRamp.GID_RAMP_K1_DOWN_HANEDA: + return "GID_RAMP_K1_DOWN_HANEDA"; + case gidRamp.GID_RAMP_K1_UP_HANEDA: + return "GID_RAMP_K1_UP_HANEDA"; + case gidRamp.GID_RAMP_K1_UP_SHIOIRI: + return "GID_RAMP_K1_UP_SHIOIRI"; + case gidRamp.GID_RAMP_YAESU_SHIODOME: + return "GID_RAMP_YAESU_SHIODOME"; + case gidRamp.GID_RAMP_YAESU_KYOBASHI: + return "GID_RAMP_YAESU_KYOBASHI"; + case gidRamp.GID_RAMP_YAESU_KANDABASHI: + return "GID_RAMP_YAESU_KANDABASHI"; + case gidRamp.GID_RAMP_MINATOMIRAI_IN_HIGASHIKANAGAWA: + return "GID_RAMP_MINATOMIRAI_IN_HIGASHIKANAGAWA"; + case gidRamp.GID_RAMP_MINATOMIRAI_IN_MINATOMIRAI: + return "GID_RAMP_MINATOMIRAI_IN_MINATOMIRAI"; + case gidRamp.GID_RAMP_MINATOMIRAI_OUT_SHINYAMASHITA: + return "GID_RAMP_MINATOMIRAI_OUT_SHINYAMASHITA"; + case gidRamp.GID_RAMP_MINATOMIRAI_OUT_MINATOMIRAI: + return "GID_RAMP_MINATOMIRAI_OUT_MINATOMIRAI"; + case gidRamp.GID_RAMP_NAGOYA_MARUNOUCHI: + return "GID_RAMP_NAGOYA_MARUNOUCHI"; + case gidRamp.GID_RAMP_OOSAKA_DOUTONBORI: + return "GID_RAMP_OOSAKA_DOUTONBORI"; + case gidRamp.GID_RAMP_KOBE_SHINKOUCHOU: + return "GID_RAMP_KOBE_SHINKOUCHOU"; + case gidRamp.GID_RAMP_KOBE_NADAOOHASHI: + return "GID_RAMP_KOBE_NADAOOHASHI"; + case gidRamp.GID_RAMP_FUKUOKA_WEST_MEIHAMA: + return "GID_RAMP_FUKUOKA_WEST_MEIHAMA"; + case gidRamp.GID_RAMP_FUKUOKA_WEST_HAKATA: + return "GID_RAMP_FUKUOKA_WEST_HAKATA"; + case gidRamp.GID_RAMP_FUKUOKA_EAST_NISHI: + return "GID_RAMP_FUKUOKA_EAST_NISHI"; + case gidRamp.GID_RAMP_FUKUOKA_EAST_HANDOUBASHI: + return "GID_RAMP_FUKUOKA_EAST_HANDOUBASHI"; + case gidRamp.GID_RAMP_HAKONE_FOR: + return "GID_RAMP_HAKONE_FOR"; + case gidRamp.GID_RAMP_HAKONE_BACK: + return "GID_RAMP_HAKONE_BACK"; + case gidRamp.GID_RAMP_TURNPIKE_UP: + return "GID_RAMP_TURNPIKE_UP"; + case gidRamp.GID_RAMP_TURNPIKE_DOWN: + return "GID_RAMP_TURNPIKE_DOWN"; + case gidRamp.GID_RAMP_HIROSHIMA_SHINONOME: + return "GID_RAMP_HIROSHIMA_SHINONOME"; + case gidRamp.GID_RAMP_HIROSHIMA_UJINA: + return "GID_RAMP_HIROSHIMA_UJINA"; + case gidRamp.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum gidPath { + GID_PATH_C1IN_KANDABASHI01 = 0, + GID_PATH_C1IN_KANDABASHI02 = 1, + GID_PATH_C1IN_KANDABASHI03 = 2, + GID_PATH_C1IN_SHIODOME01 = 3, + GID_PATH_C1OUT_KANDABASHI01 = 4, + GID_PATH_C1OUT_KANDABASHI02 = 5, + GID_PATH_C1OUT_KANDABASHI03 = 6, + GID_PATH_C1OUT_SHIBAKOUEN01 = 7, + GID_PATH_C1OUT_SHIBAKOUEN02 = 8, + GID_PATH_C1OUT_SHIBAKOUEN03 = 9, + GID_PATH_N9IN_ARIAKE01 = 10, + GID_PATH_N9IN_ARIAKE02 = 11, + GID_PATH_N9IN_ARIAKE03 = 12, + GID_PATH_N9OUT_KIBA01 = 13, + GID_PATH_N9OUT_KIBA02 = 14, + GID_PATH_N9OUT_KIBA03 = 15, + GID_PATH_WTEAST_SHIBUYA = 16, + GID_PATH_WTWEST_GAIEN = 17, + GID_PATH_WTUP_DAIKANCHOU = 18, + GID_PATH_WTDOWN_SHINJYUKU = 19, + GID_PATH_WGIN_AIRPORT01 = 20, + GID_PATH_WGIN_AIRPORT02 = 21, + GID_PATH_WGIN_AIRPORT03 = 22, + GID_PATH_WGIN_DAIKOKU01 = 23, + GID_PATH_WGOUT_13_01 = 24, + GID_PATH_WGOUT_AIRPORT01 = 25, + GID_PATH_WGOUT_AIRPORT02 = 26, + GID_PATH_KGDOWN_SHIBAURA01 = 27, + GID_PATH_KGDOWN_HANEDA01 = 28, + GID_PATH_KGDOWN_HANEDA02 = 29, + GID_PATH_KGUP_HANEDA01 = 30, + GID_PATH_KGUP_HANEDA02 = 31, + GID_PATH_KGUP_SHIOIRI01 = 32, + GID_PATH_KGUP_SHIOIRI02 = 33, + GID_PATH_YSIN_SHIODOME01 = 34, + GID_PATH_YSIN_SHIODOME02 = 35, + GID_PATH_YSOUT_KYOBASHI01 = 36, + GID_PATH_YSOUT_KANDABASHI01 = 37, + GID_PATH_KGDOWN_HIGASHIKANAGAWA01 = 38, + GID_PATH_KGDOWN_HIGASHIKANAGAWA02 = 39, + GID_PATH_KGDOWN_MINATOMIRAI01 = 40, + GID_PATH_KGDOWN_MINATOMIRAI02 = 41, + GID_PATH_KGDOWN_MINATOMIRAI03 = 42, + GID_PATH_KGUP_SHINYAMASHITA01 = 43, + GID_PATH_KGUP_SHINYAMASHITA02 = 44, + GID_PATH_KGUP_SHINYAMASHITA03 = 45, + GID_PATH_KGUP_MINATOMIRAI01 = 46, + GID_PATH_KGUP_MINATOMIRAI02 = 47, + GID_PATH_KGUP_MINATOMIRAI03 = 48, + GID_PATH_NGR_MARUNOUCHI = 49, + GID_PATH_OS_TONBORI01 = 50, + GID_PATH_OS_TONBORI02 = 51, + GID_PATH_OS_TONBORI03 = 52, + GID_PATH_OS_TONBORI04 = 53, + GID_PATH_KB_SHINKOUCHOU = 54, + GID_PATH_KB_NADA = 55, + GID_PATH_HS_SHINONOME = 56, + GID_PATH_HS_UJINA = 57, + GID_PATH_FK_MEINOHAMA = 58, + GID_PATH_FK_HAKATA = 59, + GID_PATH_FK_NISHIKOUEN = 60, + GID_PATH_FK_HANMICHIBASHI = 61, + GID_PATH_HKFOR = 62, + GID_PATH_HKBACK = 63, + GID_PATH_TP_BOTTOM = 64, + GID_PATH_TP_TOP = 65, + UNRECOGNIZED = -1, +} + +export function gidPathFromJSON(object: any): gidPath { + switch (object) { + case 0: + case "GID_PATH_C1IN_KANDABASHI01": + return gidPath.GID_PATH_C1IN_KANDABASHI01; + case 1: + case "GID_PATH_C1IN_KANDABASHI02": + return gidPath.GID_PATH_C1IN_KANDABASHI02; + case 2: + case "GID_PATH_C1IN_KANDABASHI03": + return gidPath.GID_PATH_C1IN_KANDABASHI03; + case 3: + case "GID_PATH_C1IN_SHIODOME01": + return gidPath.GID_PATH_C1IN_SHIODOME01; + case 4: + case "GID_PATH_C1OUT_KANDABASHI01": + return gidPath.GID_PATH_C1OUT_KANDABASHI01; + case 5: + case "GID_PATH_C1OUT_KANDABASHI02": + return gidPath.GID_PATH_C1OUT_KANDABASHI02; + case 6: + case "GID_PATH_C1OUT_KANDABASHI03": + return gidPath.GID_PATH_C1OUT_KANDABASHI03; + case 7: + case "GID_PATH_C1OUT_SHIBAKOUEN01": + return gidPath.GID_PATH_C1OUT_SHIBAKOUEN01; + case 8: + case "GID_PATH_C1OUT_SHIBAKOUEN02": + return gidPath.GID_PATH_C1OUT_SHIBAKOUEN02; + case 9: + case "GID_PATH_C1OUT_SHIBAKOUEN03": + return gidPath.GID_PATH_C1OUT_SHIBAKOUEN03; + case 10: + case "GID_PATH_N9IN_ARIAKE01": + return gidPath.GID_PATH_N9IN_ARIAKE01; + case 11: + case "GID_PATH_N9IN_ARIAKE02": + return gidPath.GID_PATH_N9IN_ARIAKE02; + case 12: + case "GID_PATH_N9IN_ARIAKE03": + return gidPath.GID_PATH_N9IN_ARIAKE03; + case 13: + case "GID_PATH_N9OUT_KIBA01": + return gidPath.GID_PATH_N9OUT_KIBA01; + case 14: + case "GID_PATH_N9OUT_KIBA02": + return gidPath.GID_PATH_N9OUT_KIBA02; + case 15: + case "GID_PATH_N9OUT_KIBA03": + return gidPath.GID_PATH_N9OUT_KIBA03; + case 16: + case "GID_PATH_WTEAST_SHIBUYA": + return gidPath.GID_PATH_WTEAST_SHIBUYA; + case 17: + case "GID_PATH_WTWEST_GAIEN": + return gidPath.GID_PATH_WTWEST_GAIEN; + case 18: + case "GID_PATH_WTUP_DAIKANCHOU": + return gidPath.GID_PATH_WTUP_DAIKANCHOU; + case 19: + case "GID_PATH_WTDOWN_SHINJYUKU": + return gidPath.GID_PATH_WTDOWN_SHINJYUKU; + case 20: + case "GID_PATH_WGIN_AIRPORT01": + return gidPath.GID_PATH_WGIN_AIRPORT01; + case 21: + case "GID_PATH_WGIN_AIRPORT02": + return gidPath.GID_PATH_WGIN_AIRPORT02; + case 22: + case "GID_PATH_WGIN_AIRPORT03": + return gidPath.GID_PATH_WGIN_AIRPORT03; + case 23: + case "GID_PATH_WGIN_DAIKOKU01": + return gidPath.GID_PATH_WGIN_DAIKOKU01; + case 24: + case "GID_PATH_WGOUT_13_01": + return gidPath.GID_PATH_WGOUT_13_01; + case 25: + case "GID_PATH_WGOUT_AIRPORT01": + return gidPath.GID_PATH_WGOUT_AIRPORT01; + case 26: + case "GID_PATH_WGOUT_AIRPORT02": + return gidPath.GID_PATH_WGOUT_AIRPORT02; + case 27: + case "GID_PATH_KGDOWN_SHIBAURA01": + return gidPath.GID_PATH_KGDOWN_SHIBAURA01; + case 28: + case "GID_PATH_KGDOWN_HANEDA01": + return gidPath.GID_PATH_KGDOWN_HANEDA01; + case 29: + case "GID_PATH_KGDOWN_HANEDA02": + return gidPath.GID_PATH_KGDOWN_HANEDA02; + case 30: + case "GID_PATH_KGUP_HANEDA01": + return gidPath.GID_PATH_KGUP_HANEDA01; + case 31: + case "GID_PATH_KGUP_HANEDA02": + return gidPath.GID_PATH_KGUP_HANEDA02; + case 32: + case "GID_PATH_KGUP_SHIOIRI01": + return gidPath.GID_PATH_KGUP_SHIOIRI01; + case 33: + case "GID_PATH_KGUP_SHIOIRI02": + return gidPath.GID_PATH_KGUP_SHIOIRI02; + case 34: + case "GID_PATH_YSIN_SHIODOME01": + return gidPath.GID_PATH_YSIN_SHIODOME01; + case 35: + case "GID_PATH_YSIN_SHIODOME02": + return gidPath.GID_PATH_YSIN_SHIODOME02; + case 36: + case "GID_PATH_YSOUT_KYOBASHI01": + return gidPath.GID_PATH_YSOUT_KYOBASHI01; + case 37: + case "GID_PATH_YSOUT_KANDABASHI01": + return gidPath.GID_PATH_YSOUT_KANDABASHI01; + case 38: + case "GID_PATH_KGDOWN_HIGASHIKANAGAWA01": + return gidPath.GID_PATH_KGDOWN_HIGASHIKANAGAWA01; + case 39: + case "GID_PATH_KGDOWN_HIGASHIKANAGAWA02": + return gidPath.GID_PATH_KGDOWN_HIGASHIKANAGAWA02; + case 40: + case "GID_PATH_KGDOWN_MINATOMIRAI01": + return gidPath.GID_PATH_KGDOWN_MINATOMIRAI01; + case 41: + case "GID_PATH_KGDOWN_MINATOMIRAI02": + return gidPath.GID_PATH_KGDOWN_MINATOMIRAI02; + case 42: + case "GID_PATH_KGDOWN_MINATOMIRAI03": + return gidPath.GID_PATH_KGDOWN_MINATOMIRAI03; + case 43: + case "GID_PATH_KGUP_SHINYAMASHITA01": + return gidPath.GID_PATH_KGUP_SHINYAMASHITA01; + case 44: + case "GID_PATH_KGUP_SHINYAMASHITA02": + return gidPath.GID_PATH_KGUP_SHINYAMASHITA02; + case 45: + case "GID_PATH_KGUP_SHINYAMASHITA03": + return gidPath.GID_PATH_KGUP_SHINYAMASHITA03; + case 46: + case "GID_PATH_KGUP_MINATOMIRAI01": + return gidPath.GID_PATH_KGUP_MINATOMIRAI01; + case 47: + case "GID_PATH_KGUP_MINATOMIRAI02": + return gidPath.GID_PATH_KGUP_MINATOMIRAI02; + case 48: + case "GID_PATH_KGUP_MINATOMIRAI03": + return gidPath.GID_PATH_KGUP_MINATOMIRAI03; + case 49: + case "GID_PATH_NGR_MARUNOUCHI": + return gidPath.GID_PATH_NGR_MARUNOUCHI; + case 50: + case "GID_PATH_OS_TONBORI01": + return gidPath.GID_PATH_OS_TONBORI01; + case 51: + case "GID_PATH_OS_TONBORI02": + return gidPath.GID_PATH_OS_TONBORI02; + case 52: + case "GID_PATH_OS_TONBORI03": + return gidPath.GID_PATH_OS_TONBORI03; + case 53: + case "GID_PATH_OS_TONBORI04": + return gidPath.GID_PATH_OS_TONBORI04; + case 54: + case "GID_PATH_KB_SHINKOUCHOU": + return gidPath.GID_PATH_KB_SHINKOUCHOU; + case 55: + case "GID_PATH_KB_NADA": + return gidPath.GID_PATH_KB_NADA; + case 56: + case "GID_PATH_HS_SHINONOME": + return gidPath.GID_PATH_HS_SHINONOME; + case 57: + case "GID_PATH_HS_UJINA": + return gidPath.GID_PATH_HS_UJINA; + case 58: + case "GID_PATH_FK_MEINOHAMA": + return gidPath.GID_PATH_FK_MEINOHAMA; + case 59: + case "GID_PATH_FK_HAKATA": + return gidPath.GID_PATH_FK_HAKATA; + case 60: + case "GID_PATH_FK_NISHIKOUEN": + return gidPath.GID_PATH_FK_NISHIKOUEN; + case 61: + case "GID_PATH_FK_HANMICHIBASHI": + return gidPath.GID_PATH_FK_HANMICHIBASHI; + case 62: + case "GID_PATH_HKFOR": + return gidPath.GID_PATH_HKFOR; + case 63: + case "GID_PATH_HKBACK": + return gidPath.GID_PATH_HKBACK; + case 64: + case "GID_PATH_TP_BOTTOM": + return gidPath.GID_PATH_TP_BOTTOM; + case 65: + case "GID_PATH_TP_TOP": + return gidPath.GID_PATH_TP_TOP; + case -1: + case "UNRECOGNIZED": + default: + return gidPath.UNRECOGNIZED; + } +} + +export function gidPathToJSON(object: gidPath): string { + switch (object) { + case gidPath.GID_PATH_C1IN_KANDABASHI01: + return "GID_PATH_C1IN_KANDABASHI01"; + case gidPath.GID_PATH_C1IN_KANDABASHI02: + return "GID_PATH_C1IN_KANDABASHI02"; + case gidPath.GID_PATH_C1IN_KANDABASHI03: + return "GID_PATH_C1IN_KANDABASHI03"; + case gidPath.GID_PATH_C1IN_SHIODOME01: + return "GID_PATH_C1IN_SHIODOME01"; + case gidPath.GID_PATH_C1OUT_KANDABASHI01: + return "GID_PATH_C1OUT_KANDABASHI01"; + case gidPath.GID_PATH_C1OUT_KANDABASHI02: + return "GID_PATH_C1OUT_KANDABASHI02"; + case gidPath.GID_PATH_C1OUT_KANDABASHI03: + return "GID_PATH_C1OUT_KANDABASHI03"; + case gidPath.GID_PATH_C1OUT_SHIBAKOUEN01: + return "GID_PATH_C1OUT_SHIBAKOUEN01"; + case gidPath.GID_PATH_C1OUT_SHIBAKOUEN02: + return "GID_PATH_C1OUT_SHIBAKOUEN02"; + case gidPath.GID_PATH_C1OUT_SHIBAKOUEN03: + return "GID_PATH_C1OUT_SHIBAKOUEN03"; + case gidPath.GID_PATH_N9IN_ARIAKE01: + return "GID_PATH_N9IN_ARIAKE01"; + case gidPath.GID_PATH_N9IN_ARIAKE02: + return "GID_PATH_N9IN_ARIAKE02"; + case gidPath.GID_PATH_N9IN_ARIAKE03: + return "GID_PATH_N9IN_ARIAKE03"; + case gidPath.GID_PATH_N9OUT_KIBA01: + return "GID_PATH_N9OUT_KIBA01"; + case gidPath.GID_PATH_N9OUT_KIBA02: + return "GID_PATH_N9OUT_KIBA02"; + case gidPath.GID_PATH_N9OUT_KIBA03: + return "GID_PATH_N9OUT_KIBA03"; + case gidPath.GID_PATH_WTEAST_SHIBUYA: + return "GID_PATH_WTEAST_SHIBUYA"; + case gidPath.GID_PATH_WTWEST_GAIEN: + return "GID_PATH_WTWEST_GAIEN"; + case gidPath.GID_PATH_WTUP_DAIKANCHOU: + return "GID_PATH_WTUP_DAIKANCHOU"; + case gidPath.GID_PATH_WTDOWN_SHINJYUKU: + return "GID_PATH_WTDOWN_SHINJYUKU"; + case gidPath.GID_PATH_WGIN_AIRPORT01: + return "GID_PATH_WGIN_AIRPORT01"; + case gidPath.GID_PATH_WGIN_AIRPORT02: + return "GID_PATH_WGIN_AIRPORT02"; + case gidPath.GID_PATH_WGIN_AIRPORT03: + return "GID_PATH_WGIN_AIRPORT03"; + case gidPath.GID_PATH_WGIN_DAIKOKU01: + return "GID_PATH_WGIN_DAIKOKU01"; + case gidPath.GID_PATH_WGOUT_13_01: + return "GID_PATH_WGOUT_13_01"; + case gidPath.GID_PATH_WGOUT_AIRPORT01: + return "GID_PATH_WGOUT_AIRPORT01"; + case gidPath.GID_PATH_WGOUT_AIRPORT02: + return "GID_PATH_WGOUT_AIRPORT02"; + case gidPath.GID_PATH_KGDOWN_SHIBAURA01: + return "GID_PATH_KGDOWN_SHIBAURA01"; + case gidPath.GID_PATH_KGDOWN_HANEDA01: + return "GID_PATH_KGDOWN_HANEDA01"; + case gidPath.GID_PATH_KGDOWN_HANEDA02: + return "GID_PATH_KGDOWN_HANEDA02"; + case gidPath.GID_PATH_KGUP_HANEDA01: + return "GID_PATH_KGUP_HANEDA01"; + case gidPath.GID_PATH_KGUP_HANEDA02: + return "GID_PATH_KGUP_HANEDA02"; + case gidPath.GID_PATH_KGUP_SHIOIRI01: + return "GID_PATH_KGUP_SHIOIRI01"; + case gidPath.GID_PATH_KGUP_SHIOIRI02: + return "GID_PATH_KGUP_SHIOIRI02"; + case gidPath.GID_PATH_YSIN_SHIODOME01: + return "GID_PATH_YSIN_SHIODOME01"; + case gidPath.GID_PATH_YSIN_SHIODOME02: + return "GID_PATH_YSIN_SHIODOME02"; + case gidPath.GID_PATH_YSOUT_KYOBASHI01: + return "GID_PATH_YSOUT_KYOBASHI01"; + case gidPath.GID_PATH_YSOUT_KANDABASHI01: + return "GID_PATH_YSOUT_KANDABASHI01"; + case gidPath.GID_PATH_KGDOWN_HIGASHIKANAGAWA01: + return "GID_PATH_KGDOWN_HIGASHIKANAGAWA01"; + case gidPath.GID_PATH_KGDOWN_HIGASHIKANAGAWA02: + return "GID_PATH_KGDOWN_HIGASHIKANAGAWA02"; + case gidPath.GID_PATH_KGDOWN_MINATOMIRAI01: + return "GID_PATH_KGDOWN_MINATOMIRAI01"; + case gidPath.GID_PATH_KGDOWN_MINATOMIRAI02: + return "GID_PATH_KGDOWN_MINATOMIRAI02"; + case gidPath.GID_PATH_KGDOWN_MINATOMIRAI03: + return "GID_PATH_KGDOWN_MINATOMIRAI03"; + case gidPath.GID_PATH_KGUP_SHINYAMASHITA01: + return "GID_PATH_KGUP_SHINYAMASHITA01"; + case gidPath.GID_PATH_KGUP_SHINYAMASHITA02: + return "GID_PATH_KGUP_SHINYAMASHITA02"; + case gidPath.GID_PATH_KGUP_SHINYAMASHITA03: + return "GID_PATH_KGUP_SHINYAMASHITA03"; + case gidPath.GID_PATH_KGUP_MINATOMIRAI01: + return "GID_PATH_KGUP_MINATOMIRAI01"; + case gidPath.GID_PATH_KGUP_MINATOMIRAI02: + return "GID_PATH_KGUP_MINATOMIRAI02"; + case gidPath.GID_PATH_KGUP_MINATOMIRAI03: + return "GID_PATH_KGUP_MINATOMIRAI03"; + case gidPath.GID_PATH_NGR_MARUNOUCHI: + return "GID_PATH_NGR_MARUNOUCHI"; + case gidPath.GID_PATH_OS_TONBORI01: + return "GID_PATH_OS_TONBORI01"; + case gidPath.GID_PATH_OS_TONBORI02: + return "GID_PATH_OS_TONBORI02"; + case gidPath.GID_PATH_OS_TONBORI03: + return "GID_PATH_OS_TONBORI03"; + case gidPath.GID_PATH_OS_TONBORI04: + return "GID_PATH_OS_TONBORI04"; + case gidPath.GID_PATH_KB_SHINKOUCHOU: + return "GID_PATH_KB_SHINKOUCHOU"; + case gidPath.GID_PATH_KB_NADA: + return "GID_PATH_KB_NADA"; + case gidPath.GID_PATH_HS_SHINONOME: + return "GID_PATH_HS_SHINONOME"; + case gidPath.GID_PATH_HS_UJINA: + return "GID_PATH_HS_UJINA"; + case gidPath.GID_PATH_FK_MEINOHAMA: + return "GID_PATH_FK_MEINOHAMA"; + case gidPath.GID_PATH_FK_HAKATA: + return "GID_PATH_FK_HAKATA"; + case gidPath.GID_PATH_FK_NISHIKOUEN: + return "GID_PATH_FK_NISHIKOUEN"; + case gidPath.GID_PATH_FK_HANMICHIBASHI: + return "GID_PATH_FK_HANMICHIBASHI"; + case gidPath.GID_PATH_HKFOR: + return "GID_PATH_HKFOR"; + case gidPath.GID_PATH_HKBACK: + return "GID_PATH_HKBACK"; + case gidPath.GID_PATH_TP_BOTTOM: + return "GID_PATH_TP_BOTTOM"; + case gidPath.GID_PATH_TP_TOP: + return "GID_PATH_TP_TOP"; + case gidPath.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum gidTimezone { + GID_TIMEZONE_DAY = 0, + GID_TIMEZONE_NIGHT = 1, + UNRECOGNIZED = -1, +} + +export function gidTimezoneFromJSON(object: any): gidTimezone { + switch (object) { + case 0: + case "GID_TIMEZONE_DAY": + return gidTimezone.GID_TIMEZONE_DAY; + case 1: + case "GID_TIMEZONE_NIGHT": + return gidTimezone.GID_TIMEZONE_NIGHT; + case -1: + case "UNRECOGNIZED": + default: + return gidTimezone.UNRECOGNIZED; + } +} + +export function gidTimezoneToJSON(object: gidTimezone): string { + switch (object) { + case gidTimezone.GID_TIMEZONE_DAY: + return "GID_TIMEZONE_DAY"; + case gidTimezone.GID_TIMEZONE_NIGHT: + return "GID_TIMEZONE_NIGHT"; + case gidTimezone.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum gidExtreme { + GID_EXTREME_NORMAL = 0, + GID_EXTREME_REVERSE = 1, + UNRECOGNIZED = -1, +} + +export function gidExtremeFromJSON(object: any): gidExtreme { + switch (object) { + case 0: + case "GID_EXTREME_NORMAL": + return gidExtreme.GID_EXTREME_NORMAL; + case 1: + case "GID_EXTREME_REVERSE": + return gidExtreme.GID_EXTREME_REVERSE; + case -1: + case "UNRECOGNIZED": + default: + return gidExtreme.UNRECOGNIZED; + } +} + +export function gidExtremeToJSON(object: gidExtreme): string { + switch (object) { + case gidExtreme.GID_EXTREME_NORMAL: + return "GID_EXTREME_NORMAL"; + case gidExtreme.GID_EXTREME_REVERSE: + return "GID_EXTREME_REVERSE"; + case gidExtreme.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} diff --git a/proto_src/service.ts b/proto_src/service.ts new file mode 100644 index 0000000..79f28a5 --- /dev/null +++ b/proto_src/service.ts @@ -0,0 +1,2378 @@ +/* eslint-disable */ +import { + ErrorCode, + Car, + RegisterSystemInfoResponse, + RegisterSystemStatsResponse, + RegisterGhostTrailResponse, + LoadUserResponse, + UpdateUserSessionResponse, + LoadDriveInformationResponse, + LoadCarResponse, + CreateCarResponse, + LoadGameHistoryResponse, + UpdateCarResponse, + SaveGameResultResponse, + SaveChargeResponse, + LoadGhostBattleInfoResponse, + LoadStampTargetResponse, + LockStampTargetResponse, + LoadGhostCompetitionInfoResponse, + LoadTimeAttackRecordResponse, + SaveTerminalResultResponse, + PingResponse, + LoadTerminalInformationResponse, + CreateUserResponse, + AskAccessCodeResponse, + RegisterOpponentGhostResponse, + LoadBookmarksResponse, + SaveBookmarksResponse, + GrantCarRightResponse, + LoadGhostCompetitionRankingResponse, + LoadUnreceivedUserItemsResponse, + StartTransferResponse, + SaveScreenshotResponse, + LoadScratchInformationResponse, + SaveScratchSheetResponse, + TurnScratchSheetResponse, + CheckItemReceivableCarsResponse, + ReceiveUserItemsResponse, + UpdateEventModeSerialResponse, + ConsumeUserItemResponse, + SearchCarsByLevelResponse, + LoadPathsAndTuningsResponse, + LoadGhostDriveDataResponse, + ParticipateInInviteFriendCampaignResponse, + SubmitClientLogResponse, + GhostTrail, + PlaceList, + GhostList, + CarSummary, + FileList, + GhostCompetitionTarget, + errorCodeFromJSON, + errorCodeToJSON, + RegisterSystemInfoRequest, + RegisterSystemStatsRequest, + RegisterGhostTrailRequest, + LoadUserRequest, + UpdateUserSessionRequest, + LoadDriveInformationRequest, + LoadCarRequest, + CreateCarRequest, + LoadGameHistoryRequest, + UpdateCarRequest, + SaveGameResultRequest, + SaveChargeRequest, + LoadGhostBattleInfoRequest, + LoadStampTargetRequest, + LockStampTargetRequest, + LoadGhostCompetitionInfoRequest, + LoadTimeAttackRecordRequest, + SaveTerminalResultRequest, + PingRequest, + LoadTerminalInformationRequest, + CreateUserRequest, + AskAccessCodeRequest, + RegisterOpponentGhostRequest, + LoadBookmarksRequest, + SaveBookmarksRequest, + GrantCarRightRequest, + LoadGhostCompetitionRankingRequest, + LoadUnreceivedUserItemsRequest, + StartTransferRequest, + SaveScreenshotRequest, + LoadScratchInformationRequest, + SaveScratchSheetRequest, + TurnScratchSheetRequest, + CheckItemReceivableCarsRequest, + ReceiveUserItemsRequest, + UpdateEventModeSerialRequest, + ConsumeUserItemRequest, + SearchCarsByLevelRequest, + LoadPathsAndTuningsRequest, + LoadGhostDriveDataRequest, + ParticipateInInviteFriendCampaignRequest, + SubmitClientLogRequest, +} from "./wm"; +import Long from "long"; +import * as _m0 from "protobufjs/minimal"; + +export const protobufPackage = "wm.protobuf"; + +export enum RankingType { + RANKING_TA_C1IN = 0, + RANKING_TA_C1OUT = 1, + RANKING_TA_RINGLEFT = 2, + RANKING_TA_RINGRIGHT = 3, + RANKING_TA_SUBTOKYO_3_4 = 4, + RANKING_TA_SUBTOKYO_5 = 5, + RANKING_TA_WANGANEAST = 6, + RANKING_TA_WANGANWEST = 7, + RANKING_TA_K1_DOWN = 8, + RANKING_TA_K1_UP = 9, + RANKING_TA_YAESUIN = 10, + RANKING_TA_YAESUOUT = 11, + RANKING_TA_YOKOHAMAIN = 12, + RANKING_TA_YOKOHAMAOUT = 13, + RANKING_TA_NAGOYA = 14, + RANKING_TA_OSAKA = 15, + RANKING_TA_KOBE = 16, + RANKING_TA_FUKUOKA = 17, + RANKING_TA_HAKONEFOR = 18, + RANKING_TA_HAKONEBACK = 19, + RANKING_TA_TURNPIKE_UP = 20, + RANKING_TA_TURNPIKE_DOWN = 21, + RANKING_TA_TOKYOALL = 22, + RANKING_TA_KANAGAWAALL = 23, + RANKING_TA_HIROSHIMA = 24, + RANKING_VS_STAR = 100, + RANKING_GHOST_DEFEATED_COUNT = 101, + UNRECOGNIZED = -1, +} + +export function rankingTypeFromJSON(object: any): RankingType { + switch (object) { + case 0: + case "RANKING_TA_C1IN": + return RankingType.RANKING_TA_C1IN; + case 1: + case "RANKING_TA_C1OUT": + return RankingType.RANKING_TA_C1OUT; + case 2: + case "RANKING_TA_RINGLEFT": + return RankingType.RANKING_TA_RINGLEFT; + case 3: + case "RANKING_TA_RINGRIGHT": + return RankingType.RANKING_TA_RINGRIGHT; + case 4: + case "RANKING_TA_SUBTOKYO_3_4": + return RankingType.RANKING_TA_SUBTOKYO_3_4; + case 5: + case "RANKING_TA_SUBTOKYO_5": + return RankingType.RANKING_TA_SUBTOKYO_5; + case 6: + case "RANKING_TA_WANGANEAST": + return RankingType.RANKING_TA_WANGANEAST; + case 7: + case "RANKING_TA_WANGANWEST": + return RankingType.RANKING_TA_WANGANWEST; + case 8: + case "RANKING_TA_K1_DOWN": + return RankingType.RANKING_TA_K1_DOWN; + case 9: + case "RANKING_TA_K1_UP": + return RankingType.RANKING_TA_K1_UP; + case 10: + case "RANKING_TA_YAESUIN": + return RankingType.RANKING_TA_YAESUIN; + case 11: + case "RANKING_TA_YAESUOUT": + return RankingType.RANKING_TA_YAESUOUT; + case 12: + case "RANKING_TA_YOKOHAMAIN": + return RankingType.RANKING_TA_YOKOHAMAIN; + case 13: + case "RANKING_TA_YOKOHAMAOUT": + return RankingType.RANKING_TA_YOKOHAMAOUT; + case 14: + case "RANKING_TA_NAGOYA": + return RankingType.RANKING_TA_NAGOYA; + case 15: + case "RANKING_TA_OSAKA": + return RankingType.RANKING_TA_OSAKA; + case 16: + case "RANKING_TA_KOBE": + return RankingType.RANKING_TA_KOBE; + case 17: + case "RANKING_TA_FUKUOKA": + return RankingType.RANKING_TA_FUKUOKA; + case 18: + case "RANKING_TA_HAKONEFOR": + return RankingType.RANKING_TA_HAKONEFOR; + case 19: + case "RANKING_TA_HAKONEBACK": + return RankingType.RANKING_TA_HAKONEBACK; + case 20: + case "RANKING_TA_TURNPIKE_UP": + return RankingType.RANKING_TA_TURNPIKE_UP; + case 21: + case "RANKING_TA_TURNPIKE_DOWN": + return RankingType.RANKING_TA_TURNPIKE_DOWN; + case 22: + case "RANKING_TA_TOKYOALL": + return RankingType.RANKING_TA_TOKYOALL; + case 23: + case "RANKING_TA_KANAGAWAALL": + return RankingType.RANKING_TA_KANAGAWAALL; + case 24: + case "RANKING_TA_HIROSHIMA": + return RankingType.RANKING_TA_HIROSHIMA; + case 100: + case "RANKING_VS_STAR": + return RankingType.RANKING_VS_STAR; + case 101: + case "RANKING_GHOST_DEFEATED_COUNT": + return RankingType.RANKING_GHOST_DEFEATED_COUNT; + case -1: + case "UNRECOGNIZED": + default: + return RankingType.UNRECOGNIZED; + } +} + +export function rankingTypeToJSON(object: RankingType): string { + switch (object) { + case RankingType.RANKING_TA_C1IN: + return "RANKING_TA_C1IN"; + case RankingType.RANKING_TA_C1OUT: + return "RANKING_TA_C1OUT"; + case RankingType.RANKING_TA_RINGLEFT: + return "RANKING_TA_RINGLEFT"; + case RankingType.RANKING_TA_RINGRIGHT: + return "RANKING_TA_RINGRIGHT"; + case RankingType.RANKING_TA_SUBTOKYO_3_4: + return "RANKING_TA_SUBTOKYO_3_4"; + case RankingType.RANKING_TA_SUBTOKYO_5: + return "RANKING_TA_SUBTOKYO_5"; + case RankingType.RANKING_TA_WANGANEAST: + return "RANKING_TA_WANGANEAST"; + case RankingType.RANKING_TA_WANGANWEST: + return "RANKING_TA_WANGANWEST"; + case RankingType.RANKING_TA_K1_DOWN: + return "RANKING_TA_K1_DOWN"; + case RankingType.RANKING_TA_K1_UP: + return "RANKING_TA_K1_UP"; + case RankingType.RANKING_TA_YAESUIN: + return "RANKING_TA_YAESUIN"; + case RankingType.RANKING_TA_YAESUOUT: + return "RANKING_TA_YAESUOUT"; + case RankingType.RANKING_TA_YOKOHAMAIN: + return "RANKING_TA_YOKOHAMAIN"; + case RankingType.RANKING_TA_YOKOHAMAOUT: + return "RANKING_TA_YOKOHAMAOUT"; + case RankingType.RANKING_TA_NAGOYA: + return "RANKING_TA_NAGOYA"; + case RankingType.RANKING_TA_OSAKA: + return "RANKING_TA_OSAKA"; + case RankingType.RANKING_TA_KOBE: + return "RANKING_TA_KOBE"; + case RankingType.RANKING_TA_FUKUOKA: + return "RANKING_TA_FUKUOKA"; + case RankingType.RANKING_TA_HAKONEFOR: + return "RANKING_TA_HAKONEFOR"; + case RankingType.RANKING_TA_HAKONEBACK: + return "RANKING_TA_HAKONEBACK"; + case RankingType.RANKING_TA_TURNPIKE_UP: + return "RANKING_TA_TURNPIKE_UP"; + case RankingType.RANKING_TA_TURNPIKE_DOWN: + return "RANKING_TA_TURNPIKE_DOWN"; + case RankingType.RANKING_TA_TOKYOALL: + return "RANKING_TA_TOKYOALL"; + case RankingType.RANKING_TA_KANAGAWAALL: + return "RANKING_TA_KANAGAWAALL"; + case RankingType.RANKING_TA_HIROSHIMA: + return "RANKING_TA_HIROSHIMA"; + case RankingType.RANKING_VS_STAR: + return "RANKING_VS_STAR"; + case RankingType.RANKING_GHOST_DEFEATED_COUNT: + return "RANKING_GHOST_DEFEATED_COUNT"; + case RankingType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface PlaceListQuery { + regionId: number; +} + +export interface GhostListQuery { + carId: number; + area: number; +} + +export interface GhostTrailQuery { + carId: number; + area: number; + trailId: number; +} + +export interface CarSummaryQuery { + regionId: number; + ghostLevel: number; + manufacturer: number; + model: number; + name: string; + searchCode: string; + lastPlayedPlaceId: string; + limit: number; +} + +export interface FileListQuery {} + +export interface GhostCompetitionTargetQuery { + competitionId: number; + periodId: number; +} + +export interface LockCrownRequest { + carId: number; + area: number; + lockTime: number; +} + +export interface LockCrownResponse { + error: ErrorCode; +} + +export interface Crown { + carId: number; + area: number; + unlockAt: number; + car: Car | undefined; +} + +export interface CrownListQuery { + carId: number; + area: number; +} + +export interface CrownList { + crowns: Crown[]; +} + +export interface RankingQuery { + rankingType: RankingType; +} + +export interface Ranking { + lists: Ranking_List[]; +} + +export interface Ranking_List { + rankingType: RankingType; + topRecords: Ranking_Entry[]; +} + +export interface Ranking_Entry { + rank: number; + result: number; + carId: number; + name: string; + regionId: number; + model: number; + visualModel: number; + defaultColor: number; + tunePower: number; + tuneHandling: number; + title: string; + level: number; +} + +function createBasePlaceListQuery(): PlaceListQuery { + return { regionId: 0 }; +} + +export const PlaceListQuery = { + encode( + message: PlaceListQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.regionId !== 0) { + writer.uint32(8).uint32(message.regionId); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): PlaceListQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePlaceListQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.regionId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): PlaceListQuery { + return { + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + }; + }, + + toJSON(message: PlaceListQuery): unknown { + const obj: any = {}; + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): PlaceListQuery { + const message = createBasePlaceListQuery(); + message.regionId = object.regionId ?? 0; + return message; + }, +}; + +function createBaseGhostListQuery(): GhostListQuery { + return { carId: 0, area: 0 }; +} + +export const GhostListQuery = { + encode( + message: GhostListQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GhostListQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostListQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.area = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostListQuery { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + }; + }, + + toJSON(message: GhostListQuery): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.area !== undefined && (obj.area = Math.round(message.area)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostListQuery { + const message = createBaseGhostListQuery(); + message.carId = object.carId ?? 0; + message.area = object.area ?? 0; + return message; + }, +}; + +function createBaseGhostTrailQuery(): GhostTrailQuery { + return { carId: 0, area: 0, trailId: 0 }; +} + +export const GhostTrailQuery = { + encode( + message: GhostTrailQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + if (message.trailId !== 0) { + writer.uint32(24).uint64(message.trailId); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GhostTrailQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostTrailQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.area = reader.uint32(); + break; + case 3: + message.trailId = longToNumber(reader.uint64() as Long); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostTrailQuery { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + trailId: isSet(object.trailId) ? Number(object.trailId) : 0, + }; + }, + + toJSON(message: GhostTrailQuery): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.trailId !== undefined && + (obj.trailId = Math.round(message.trailId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostTrailQuery { + const message = createBaseGhostTrailQuery(); + message.carId = object.carId ?? 0; + message.area = object.area ?? 0; + message.trailId = object.trailId ?? 0; + return message; + }, +}; + +function createBaseCarSummaryQuery(): CarSummaryQuery { + return { + regionId: 0, + ghostLevel: 0, + manufacturer: 0, + model: 0, + name: "", + searchCode: "", + lastPlayedPlaceId: "", + limit: 0, + }; +} + +export const CarSummaryQuery = { + encode( + message: CarSummaryQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.regionId !== 0) { + writer.uint32(8).uint32(message.regionId); + } + if (message.ghostLevel !== 0) { + writer.uint32(16).uint32(message.ghostLevel); + } + if (message.manufacturer !== 0) { + writer.uint32(24).uint32(message.manufacturer); + } + if (message.model !== 0) { + writer.uint32(32).uint32(message.model); + } + if (message.name !== "") { + writer.uint32(42).string(message.name); + } + if (message.searchCode !== "") { + writer.uint32(50).string(message.searchCode); + } + if (message.lastPlayedPlaceId !== "") { + writer.uint32(58).string(message.lastPlayedPlaceId); + } + if (message.limit !== 0) { + writer.uint32(64).uint32(message.limit); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CarSummaryQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCarSummaryQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.regionId = reader.uint32(); + break; + case 2: + message.ghostLevel = reader.uint32(); + break; + case 3: + message.manufacturer = reader.uint32(); + break; + case 4: + message.model = reader.uint32(); + break; + case 5: + message.name = reader.string(); + break; + case 6: + message.searchCode = reader.string(); + break; + case 7: + message.lastPlayedPlaceId = reader.string(); + break; + case 8: + message.limit = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CarSummaryQuery { + return { + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + ghostLevel: isSet(object.ghostLevel) ? Number(object.ghostLevel) : 0, + manufacturer: isSet(object.manufacturer) + ? Number(object.manufacturer) + : 0, + model: isSet(object.model) ? Number(object.model) : 0, + name: isSet(object.name) ? String(object.name) : "", + searchCode: isSet(object.searchCode) ? String(object.searchCode) : "", + lastPlayedPlaceId: isSet(object.lastPlayedPlaceId) + ? String(object.lastPlayedPlaceId) + : "", + limit: isSet(object.limit) ? Number(object.limit) : 0, + }; + }, + + toJSON(message: CarSummaryQuery): unknown { + const obj: any = {}; + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + message.ghostLevel !== undefined && + (obj.ghostLevel = Math.round(message.ghostLevel)); + message.manufacturer !== undefined && + (obj.manufacturer = Math.round(message.manufacturer)); + message.model !== undefined && (obj.model = Math.round(message.model)); + message.name !== undefined && (obj.name = message.name); + message.searchCode !== undefined && (obj.searchCode = message.searchCode); + message.lastPlayedPlaceId !== undefined && + (obj.lastPlayedPlaceId = message.lastPlayedPlaceId); + message.limit !== undefined && (obj.limit = Math.round(message.limit)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CarSummaryQuery { + const message = createBaseCarSummaryQuery(); + message.regionId = object.regionId ?? 0; + message.ghostLevel = object.ghostLevel ?? 0; + message.manufacturer = object.manufacturer ?? 0; + message.model = object.model ?? 0; + message.name = object.name ?? ""; + message.searchCode = object.searchCode ?? ""; + message.lastPlayedPlaceId = object.lastPlayedPlaceId ?? ""; + message.limit = object.limit ?? 0; + return message; + }, +}; + +function createBaseFileListQuery(): FileListQuery { + return {}; +} + +export const FileListQuery = { + encode( + _: FileListQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): FileListQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFileListQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): FileListQuery { + return {}; + }, + + toJSON(_: FileListQuery): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial, I>>( + _: I + ): FileListQuery { + const message = createBaseFileListQuery(); + return message; + }, +}; + +function createBaseGhostCompetitionTargetQuery(): GhostCompetitionTargetQuery { + return { competitionId: 0, periodId: 0 }; +} + +export const GhostCompetitionTargetQuery = { + encode( + message: GhostCompetitionTargetQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.competitionId !== 0) { + writer.uint32(8).uint32(message.competitionId); + } + if (message.periodId !== 0) { + writer.uint32(16).uint32(message.periodId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): GhostCompetitionTargetQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostCompetitionTargetQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.competitionId = reader.uint32(); + break; + case 2: + message.periodId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostCompetitionTargetQuery { + return { + competitionId: isSet(object.competitionId) + ? Number(object.competitionId) + : 0, + periodId: isSet(object.periodId) ? Number(object.periodId) : 0, + }; + }, + + toJSON(message: GhostCompetitionTargetQuery): unknown { + const obj: any = {}; + message.competitionId !== undefined && + (obj.competitionId = Math.round(message.competitionId)); + message.periodId !== undefined && + (obj.periodId = Math.round(message.periodId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostCompetitionTargetQuery { + const message = createBaseGhostCompetitionTargetQuery(); + message.competitionId = object.competitionId ?? 0; + message.periodId = object.periodId ?? 0; + return message; + }, +}; + +function createBaseLockCrownRequest(): LockCrownRequest { + return { carId: 0, area: 0, lockTime: 0 }; +} + +export const LockCrownRequest = { + encode( + message: LockCrownRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + if (message.lockTime !== 0) { + writer.uint32(24).uint32(message.lockTime); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): LockCrownRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLockCrownRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.area = reader.uint32(); + break; + case 3: + message.lockTime = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LockCrownRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + lockTime: isSet(object.lockTime) ? Number(object.lockTime) : 0, + }; + }, + + toJSON(message: LockCrownRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.lockTime !== undefined && + (obj.lockTime = Math.round(message.lockTime)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LockCrownRequest { + const message = createBaseLockCrownRequest(); + message.carId = object.carId ?? 0; + message.area = object.area ?? 0; + message.lockTime = object.lockTime ?? 0; + return message; + }, +}; + +function createBaseLockCrownResponse(): LockCrownResponse { + return { error: 0 }; +} + +export const LockCrownResponse = { + encode( + message: LockCrownResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): LockCrownResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLockCrownResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LockCrownResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: LockCrownResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LockCrownResponse { + const message = createBaseLockCrownResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseCrown(): Crown { + return { carId: 0, area: 0, unlockAt: 0, car: undefined }; +} + +export const Crown = { + encode(message: Crown, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + if (message.unlockAt !== 0) { + writer.uint32(24).uint32(message.unlockAt); + } + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(34).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Crown { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCrown(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.area = reader.uint32(); + break; + case 3: + message.unlockAt = reader.uint32(); + break; + case 4: + message.car = Car.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Crown { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + unlockAt: isSet(object.unlockAt) ? Number(object.unlockAt) : 0, + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + }; + }, + + toJSON(message: Crown): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.unlockAt !== undefined && + (obj.unlockAt = Math.round(message.unlockAt)); + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + return obj; + }, + + fromPartial, I>>(object: I): Crown { + const message = createBaseCrown(); + message.carId = object.carId ?? 0; + message.area = object.area ?? 0; + message.unlockAt = object.unlockAt ?? 0; + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + return message; + }, +}; + +function createBaseCrownListQuery(): CrownListQuery { + return { carId: 0, area: 0 }; +} + +export const CrownListQuery = { + encode( + message: CrownListQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CrownListQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCrownListQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.area = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CrownListQuery { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + }; + }, + + toJSON(message: CrownListQuery): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.area !== undefined && (obj.area = Math.round(message.area)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CrownListQuery { + const message = createBaseCrownListQuery(); + message.carId = object.carId ?? 0; + message.area = object.area ?? 0; + return message; + }, +}; + +function createBaseCrownList(): CrownList { + return { crowns: [] }; +} + +export const CrownList = { + encode( + message: CrownList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.crowns) { + Crown.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CrownList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCrownList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.crowns.push(Crown.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CrownList { + return { + crowns: Array.isArray(object?.crowns) + ? object.crowns.map((e: any) => Crown.fromJSON(e)) + : [], + }; + }, + + toJSON(message: CrownList): unknown { + const obj: any = {}; + if (message.crowns) { + obj.crowns = message.crowns.map((e) => (e ? Crown.toJSON(e) : undefined)); + } else { + obj.crowns = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): CrownList { + const message = createBaseCrownList(); + message.crowns = object.crowns?.map((e) => Crown.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseRankingQuery(): RankingQuery { + return { rankingType: 0 }; +} + +export const RankingQuery = { + encode( + message: RankingQuery, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.rankingType !== 0) { + writer.uint32(8).int32(message.rankingType); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): RankingQuery { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRankingQuery(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.rankingType = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RankingQuery { + return { + rankingType: isSet(object.rankingType) + ? rankingTypeFromJSON(object.rankingType) + : 0, + }; + }, + + toJSON(message: RankingQuery): unknown { + const obj: any = {}; + message.rankingType !== undefined && + (obj.rankingType = rankingTypeToJSON(message.rankingType)); + return obj; + }, + + fromPartial, I>>( + object: I + ): RankingQuery { + const message = createBaseRankingQuery(); + message.rankingType = object.rankingType ?? 0; + return message; + }, +}; + +function createBaseRanking(): Ranking { + return { lists: [] }; +} + +export const Ranking = { + encode( + message: Ranking, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.lists) { + Ranking_List.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Ranking { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRanking(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.lists.push(Ranking_List.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Ranking { + return { + lists: Array.isArray(object?.lists) + ? object.lists.map((e: any) => Ranking_List.fromJSON(e)) + : [], + }; + }, + + toJSON(message: Ranking): unknown { + const obj: any = {}; + if (message.lists) { + obj.lists = message.lists.map((e) => + e ? Ranking_List.toJSON(e) : undefined + ); + } else { + obj.lists = []; + } + return obj; + }, + + fromPartial, I>>(object: I): Ranking { + const message = createBaseRanking(); + message.lists = object.lists?.map((e) => Ranking_List.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseRanking_List(): Ranking_List { + return { rankingType: 0, topRecords: [] }; +} + +export const Ranking_List = { + encode( + message: Ranking_List, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.rankingType !== 0) { + writer.uint32(8).int32(message.rankingType); + } + for (const v of message.topRecords) { + Ranking_Entry.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Ranking_List { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRanking_List(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.rankingType = reader.int32() as any; + break; + case 2: + message.topRecords.push( + Ranking_Entry.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Ranking_List { + return { + rankingType: isSet(object.rankingType) + ? rankingTypeFromJSON(object.rankingType) + : 0, + topRecords: Array.isArray(object?.topRecords) + ? object.topRecords.map((e: any) => Ranking_Entry.fromJSON(e)) + : [], + }; + }, + + toJSON(message: Ranking_List): unknown { + const obj: any = {}; + message.rankingType !== undefined && + (obj.rankingType = rankingTypeToJSON(message.rankingType)); + if (message.topRecords) { + obj.topRecords = message.topRecords.map((e) => + e ? Ranking_Entry.toJSON(e) : undefined + ); + } else { + obj.topRecords = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): Ranking_List { + const message = createBaseRanking_List(); + message.rankingType = object.rankingType ?? 0; + message.topRecords = + object.topRecords?.map((e) => Ranking_Entry.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseRanking_Entry(): Ranking_Entry { + return { + rank: 0, + result: 0, + carId: 0, + name: "", + regionId: 0, + model: 0, + visualModel: 0, + defaultColor: 0, + tunePower: 0, + tuneHandling: 0, + title: "", + level: 0, + }; +} + +export const Ranking_Entry = { + encode( + message: Ranking_Entry, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.rank !== 0) { + writer.uint32(8).uint32(message.rank); + } + if (message.result !== 0) { + writer.uint32(16).uint32(message.result); + } + if (message.carId !== 0) { + writer.uint32(24).uint32(message.carId); + } + if (message.name !== "") { + writer.uint32(34).string(message.name); + } + if (message.regionId !== 0) { + writer.uint32(40).uint32(message.regionId); + } + if (message.model !== 0) { + writer.uint32(48).uint32(message.model); + } + if (message.visualModel !== 0) { + writer.uint32(56).uint32(message.visualModel); + } + if (message.defaultColor !== 0) { + writer.uint32(64).uint32(message.defaultColor); + } + if (message.tunePower !== 0) { + writer.uint32(72).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(80).uint32(message.tuneHandling); + } + if (message.title !== "") { + writer.uint32(90).string(message.title); + } + if (message.level !== 0) { + writer.uint32(96).uint32(message.level); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Ranking_Entry { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRanking_Entry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.rank = reader.uint32(); + break; + case 2: + message.result = reader.uint32(); + break; + case 3: + message.carId = reader.uint32(); + break; + case 4: + message.name = reader.string(); + break; + case 5: + message.regionId = reader.uint32(); + break; + case 6: + message.model = reader.uint32(); + break; + case 7: + message.visualModel = reader.uint32(); + break; + case 8: + message.defaultColor = reader.uint32(); + break; + case 9: + message.tunePower = reader.uint32(); + break; + case 10: + message.tuneHandling = reader.uint32(); + break; + case 11: + message.title = reader.string(); + break; + case 12: + message.level = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Ranking_Entry { + return { + rank: isSet(object.rank) ? Number(object.rank) : 0, + result: isSet(object.result) ? Number(object.result) : 0, + carId: isSet(object.carId) ? Number(object.carId) : 0, + name: isSet(object.name) ? String(object.name) : "", + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + model: isSet(object.model) ? Number(object.model) : 0, + visualModel: isSet(object.visualModel) ? Number(object.visualModel) : 0, + defaultColor: isSet(object.defaultColor) + ? Number(object.defaultColor) + : 0, + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + title: isSet(object.title) ? String(object.title) : "", + level: isSet(object.level) ? Number(object.level) : 0, + }; + }, + + toJSON(message: Ranking_Entry): unknown { + const obj: any = {}; + message.rank !== undefined && (obj.rank = Math.round(message.rank)); + message.result !== undefined && (obj.result = Math.round(message.result)); + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.name !== undefined && (obj.name = message.name); + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + message.model !== undefined && (obj.model = Math.round(message.model)); + message.visualModel !== undefined && + (obj.visualModel = Math.round(message.visualModel)); + message.defaultColor !== undefined && + (obj.defaultColor = Math.round(message.defaultColor)); + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.title !== undefined && (obj.title = message.title); + message.level !== undefined && (obj.level = Math.round(message.level)); + return obj; + }, + + fromPartial, I>>( + object: I + ): Ranking_Entry { + const message = createBaseRanking_Entry(); + message.rank = object.rank ?? 0; + message.result = object.result ?? 0; + message.carId = object.carId ?? 0; + message.name = object.name ?? ""; + message.regionId = object.regionId ?? 0; + message.model = object.model ?? 0; + message.visualModel = object.visualModel ?? 0; + message.defaultColor = object.defaultColor ?? 0; + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.title = object.title ?? ""; + message.level = object.level ?? 0; + return message; + }, +}; + +export interface Rpc { + register_system_info( + request: RegisterSystemInfoRequest + ): Promise; + register_system_stats( + request: RegisterSystemStatsRequest + ): Promise; + register_ghost_trail( + request: RegisterGhostTrailRequest + ): Promise; + load_user(request: LoadUserRequest): Promise; + update_user_session( + request: UpdateUserSessionRequest + ): Promise; + load_drive_information( + request: LoadDriveInformationRequest + ): Promise; + load_car(request: LoadCarRequest): Promise; + create_car(request: CreateCarRequest): Promise; + load_game_history( + request: LoadGameHistoryRequest + ): Promise; + update_car(request: UpdateCarRequest): Promise; + save_game_result( + request: SaveGameResultRequest + ): Promise; + save_charge(request: SaveChargeRequest): Promise; + load_ghost_battle_info( + request: LoadGhostBattleInfoRequest + ): Promise; + load_stamp_target( + request: LoadStampTargetRequest + ): Promise; + lock_stamp_target( + request: LockStampTargetRequest + ): Promise; + load_ghost_competition_info( + request: LoadGhostCompetitionInfoRequest + ): Promise; + load_time_attack_record( + request: LoadTimeAttackRecordRequest + ): Promise; + save_terminal_result( + request: SaveTerminalResultRequest + ): Promise; + ping(request: PingRequest): Promise; + load_terminal_information( + request: LoadTerminalInformationRequest + ): Promise; + create_user(request: CreateUserRequest): Promise; + ask_access_code( + request: AskAccessCodeRequest + ): Promise; + register_opponent_ghost( + request: RegisterOpponentGhostRequest + ): Promise; + load_bookmarks(request: LoadBookmarksRequest): Promise; + save_bookmarks(request: SaveBookmarksRequest): Promise; + grant_car_right( + request: GrantCarRightRequest + ): Promise; + load_ghost_competition_ranking( + request: LoadGhostCompetitionRankingRequest + ): Promise; + load_unreceived_user_items( + request: LoadUnreceivedUserItemsRequest + ): Promise; + start_transfer(request: StartTransferRequest): Promise; + save_screenshot( + request: SaveScreenshotRequest + ): Promise; + load_scratch_information( + request: LoadScratchInformationRequest + ): Promise; + save_scratch_sheet( + request: SaveScratchSheetRequest + ): Promise; + turn_scratch_sheet( + request: TurnScratchSheetRequest + ): Promise; + check_item_receivable_cars( + request: CheckItemReceivableCarsRequest + ): Promise; + receive_user_items( + request: ReceiveUserItemsRequest + ): Promise; + update_event_mode_serial( + request: UpdateEventModeSerialRequest + ): Promise; + consume_user_item( + request: ConsumeUserItemRequest + ): Promise; + search_cars_by_level( + request: SearchCarsByLevelRequest + ): Promise; + load_paths_and_tunings( + request: LoadPathsAndTuningsRequest + ): Promise; + load_ghost_drive_data( + request: LoadGhostDriveDataRequest + ): Promise; + participate_in_invite_friend_campaign( + request: ParticipateInInviteFriendCampaignRequest + ): Promise; + lock_crown(request: LockCrownRequest): Promise; + submit_client_log( + request: SubmitClientLogRequest + ): Promise; +} + +export class RpcClientImpl implements Rpc { + private readonly rpc: _Rpc; + constructor(rpc: _Rpc) { + this.rpc = rpc; + this.register_system_info = this.register_system_info.bind(this); + this.register_system_stats = this.register_system_stats.bind(this); + this.register_ghost_trail = this.register_ghost_trail.bind(this); + this.load_user = this.load_user.bind(this); + this.update_user_session = this.update_user_session.bind(this); + this.load_drive_information = this.load_drive_information.bind(this); + this.load_car = this.load_car.bind(this); + this.create_car = this.create_car.bind(this); + this.load_game_history = this.load_game_history.bind(this); + this.update_car = this.update_car.bind(this); + this.save_game_result = this.save_game_result.bind(this); + this.save_charge = this.save_charge.bind(this); + this.load_ghost_battle_info = this.load_ghost_battle_info.bind(this); + this.load_stamp_target = this.load_stamp_target.bind(this); + this.lock_stamp_target = this.lock_stamp_target.bind(this); + this.load_ghost_competition_info = + this.load_ghost_competition_info.bind(this); + this.load_time_attack_record = this.load_time_attack_record.bind(this); + this.save_terminal_result = this.save_terminal_result.bind(this); + this.ping = this.ping.bind(this); + this.load_terminal_information = this.load_terminal_information.bind(this); + this.create_user = this.create_user.bind(this); + this.ask_access_code = this.ask_access_code.bind(this); + this.register_opponent_ghost = this.register_opponent_ghost.bind(this); + this.load_bookmarks = this.load_bookmarks.bind(this); + this.save_bookmarks = this.save_bookmarks.bind(this); + this.grant_car_right = this.grant_car_right.bind(this); + this.load_ghost_competition_ranking = + this.load_ghost_competition_ranking.bind(this); + this.load_unreceived_user_items = + this.load_unreceived_user_items.bind(this); + this.start_transfer = this.start_transfer.bind(this); + this.save_screenshot = this.save_screenshot.bind(this); + this.load_scratch_information = this.load_scratch_information.bind(this); + this.save_scratch_sheet = this.save_scratch_sheet.bind(this); + this.turn_scratch_sheet = this.turn_scratch_sheet.bind(this); + this.check_item_receivable_cars = + this.check_item_receivable_cars.bind(this); + this.receive_user_items = this.receive_user_items.bind(this); + this.update_event_mode_serial = this.update_event_mode_serial.bind(this); + this.consume_user_item = this.consume_user_item.bind(this); + this.search_cars_by_level = this.search_cars_by_level.bind(this); + this.load_paths_and_tunings = this.load_paths_and_tunings.bind(this); + this.load_ghost_drive_data = this.load_ghost_drive_data.bind(this); + this.participate_in_invite_friend_campaign = + this.participate_in_invite_friend_campaign.bind(this); + this.lock_crown = this.lock_crown.bind(this); + this.submit_client_log = this.submit_client_log.bind(this); + } + register_system_info( + request: RegisterSystemInfoRequest + ): Promise { + const data = RegisterSystemInfoRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "register_system_info", + data + ); + return promise.then((data) => + RegisterSystemInfoResponse.decode(new _m0.Reader(data)) + ); + } + + register_system_stats( + request: RegisterSystemStatsRequest + ): Promise { + const data = RegisterSystemStatsRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "register_system_stats", + data + ); + return promise.then((data) => + RegisterSystemStatsResponse.decode(new _m0.Reader(data)) + ); + } + + register_ghost_trail( + request: RegisterGhostTrailRequest + ): Promise { + const data = RegisterGhostTrailRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "register_ghost_trail", + data + ); + return promise.then((data) => + RegisterGhostTrailResponse.decode(new _m0.Reader(data)) + ); + } + + load_user(request: LoadUserRequest): Promise { + const data = LoadUserRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "load_user", data); + return promise.then((data) => + LoadUserResponse.decode(new _m0.Reader(data)) + ); + } + + update_user_session( + request: UpdateUserSessionRequest + ): Promise { + const data = UpdateUserSessionRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "update_user_session", + data + ); + return promise.then((data) => + UpdateUserSessionResponse.decode(new _m0.Reader(data)) + ); + } + + load_drive_information( + request: LoadDriveInformationRequest + ): Promise { + const data = LoadDriveInformationRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_drive_information", + data + ); + return promise.then((data) => + LoadDriveInformationResponse.decode(new _m0.Reader(data)) + ); + } + + load_car(request: LoadCarRequest): Promise { + const data = LoadCarRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "load_car", data); + return promise.then((data) => LoadCarResponse.decode(new _m0.Reader(data))); + } + + create_car(request: CreateCarRequest): Promise { + const data = CreateCarRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "create_car", data); + return promise.then((data) => + CreateCarResponse.decode(new _m0.Reader(data)) + ); + } + + load_game_history( + request: LoadGameHistoryRequest + ): Promise { + const data = LoadGameHistoryRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_game_history", + data + ); + return promise.then((data) => + LoadGameHistoryResponse.decode(new _m0.Reader(data)) + ); + } + + update_car(request: UpdateCarRequest): Promise { + const data = UpdateCarRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "update_car", data); + return promise.then((data) => + UpdateCarResponse.decode(new _m0.Reader(data)) + ); + } + + save_game_result( + request: SaveGameResultRequest + ): Promise { + const data = SaveGameResultRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "save_game_result", + data + ); + return promise.then((data) => + SaveGameResultResponse.decode(new _m0.Reader(data)) + ); + } + + save_charge(request: SaveChargeRequest): Promise { + const data = SaveChargeRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "save_charge", data); + return promise.then((data) => + SaveChargeResponse.decode(new _m0.Reader(data)) + ); + } + + load_ghost_battle_info( + request: LoadGhostBattleInfoRequest + ): Promise { + const data = LoadGhostBattleInfoRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_ghost_battle_info", + data + ); + return promise.then((data) => + LoadGhostBattleInfoResponse.decode(new _m0.Reader(data)) + ); + } + + load_stamp_target( + request: LoadStampTargetRequest + ): Promise { + const data = LoadStampTargetRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_stamp_target", + data + ); + return promise.then((data) => + LoadStampTargetResponse.decode(new _m0.Reader(data)) + ); + } + + lock_stamp_target( + request: LockStampTargetRequest + ): Promise { + const data = LockStampTargetRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "lock_stamp_target", + data + ); + return promise.then((data) => + LockStampTargetResponse.decode(new _m0.Reader(data)) + ); + } + + load_ghost_competition_info( + request: LoadGhostCompetitionInfoRequest + ): Promise { + const data = LoadGhostCompetitionInfoRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_ghost_competition_info", + data + ); + return promise.then((data) => + LoadGhostCompetitionInfoResponse.decode(new _m0.Reader(data)) + ); + } + + load_time_attack_record( + request: LoadTimeAttackRecordRequest + ): Promise { + const data = LoadTimeAttackRecordRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_time_attack_record", + data + ); + return promise.then((data) => + LoadTimeAttackRecordResponse.decode(new _m0.Reader(data)) + ); + } + + save_terminal_result( + request: SaveTerminalResultRequest + ): Promise { + const data = SaveTerminalResultRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "save_terminal_result", + data + ); + return promise.then((data) => + SaveTerminalResultResponse.decode(new _m0.Reader(data)) + ); + } + + ping(request: PingRequest): Promise { + const data = PingRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "ping", data); + return promise.then((data) => PingResponse.decode(new _m0.Reader(data))); + } + + load_terminal_information( + request: LoadTerminalInformationRequest + ): Promise { + const data = LoadTerminalInformationRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_terminal_information", + data + ); + return promise.then((data) => + LoadTerminalInformationResponse.decode(new _m0.Reader(data)) + ); + } + + create_user(request: CreateUserRequest): Promise { + const data = CreateUserRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "create_user", data); + return promise.then((data) => + CreateUserResponse.decode(new _m0.Reader(data)) + ); + } + + ask_access_code( + request: AskAccessCodeRequest + ): Promise { + const data = AskAccessCodeRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "ask_access_code", + data + ); + return promise.then((data) => + AskAccessCodeResponse.decode(new _m0.Reader(data)) + ); + } + + register_opponent_ghost( + request: RegisterOpponentGhostRequest + ): Promise { + const data = RegisterOpponentGhostRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "register_opponent_ghost", + data + ); + return promise.then((data) => + RegisterOpponentGhostResponse.decode(new _m0.Reader(data)) + ); + } + + load_bookmarks( + request: LoadBookmarksRequest + ): Promise { + const data = LoadBookmarksRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "load_bookmarks", data); + return promise.then((data) => + LoadBookmarksResponse.decode(new _m0.Reader(data)) + ); + } + + save_bookmarks( + request: SaveBookmarksRequest + ): Promise { + const data = SaveBookmarksRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "save_bookmarks", data); + return promise.then((data) => + SaveBookmarksResponse.decode(new _m0.Reader(data)) + ); + } + + grant_car_right( + request: GrantCarRightRequest + ): Promise { + const data = GrantCarRightRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "grant_car_right", + data + ); + return promise.then((data) => + GrantCarRightResponse.decode(new _m0.Reader(data)) + ); + } + + load_ghost_competition_ranking( + request: LoadGhostCompetitionRankingRequest + ): Promise { + const data = LoadGhostCompetitionRankingRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_ghost_competition_ranking", + data + ); + return promise.then((data) => + LoadGhostCompetitionRankingResponse.decode(new _m0.Reader(data)) + ); + } + + load_unreceived_user_items( + request: LoadUnreceivedUserItemsRequest + ): Promise { + const data = LoadUnreceivedUserItemsRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_unreceived_user_items", + data + ); + return promise.then((data) => + LoadUnreceivedUserItemsResponse.decode(new _m0.Reader(data)) + ); + } + + start_transfer( + request: StartTransferRequest + ): Promise { + const data = StartTransferRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "start_transfer", data); + return promise.then((data) => + StartTransferResponse.decode(new _m0.Reader(data)) + ); + } + + save_screenshot( + request: SaveScreenshotRequest + ): Promise { + const data = SaveScreenshotRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "save_screenshot", + data + ); + return promise.then((data) => + SaveScreenshotResponse.decode(new _m0.Reader(data)) + ); + } + + load_scratch_information( + request: LoadScratchInformationRequest + ): Promise { + const data = LoadScratchInformationRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_scratch_information", + data + ); + return promise.then((data) => + LoadScratchInformationResponse.decode(new _m0.Reader(data)) + ); + } + + save_scratch_sheet( + request: SaveScratchSheetRequest + ): Promise { + const data = SaveScratchSheetRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "save_scratch_sheet", + data + ); + return promise.then((data) => + SaveScratchSheetResponse.decode(new _m0.Reader(data)) + ); + } + + turn_scratch_sheet( + request: TurnScratchSheetRequest + ): Promise { + const data = TurnScratchSheetRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "turn_scratch_sheet", + data + ); + return promise.then((data) => + TurnScratchSheetResponse.decode(new _m0.Reader(data)) + ); + } + + check_item_receivable_cars( + request: CheckItemReceivableCarsRequest + ): Promise { + const data = CheckItemReceivableCarsRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "check_item_receivable_cars", + data + ); + return promise.then((data) => + CheckItemReceivableCarsResponse.decode(new _m0.Reader(data)) + ); + } + + receive_user_items( + request: ReceiveUserItemsRequest + ): Promise { + const data = ReceiveUserItemsRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "receive_user_items", + data + ); + return promise.then((data) => + ReceiveUserItemsResponse.decode(new _m0.Reader(data)) + ); + } + + update_event_mode_serial( + request: UpdateEventModeSerialRequest + ): Promise { + const data = UpdateEventModeSerialRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "update_event_mode_serial", + data + ); + return promise.then((data) => + UpdateEventModeSerialResponse.decode(new _m0.Reader(data)) + ); + } + + consume_user_item( + request: ConsumeUserItemRequest + ): Promise { + const data = ConsumeUserItemRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "consume_user_item", + data + ); + return promise.then((data) => + ConsumeUserItemResponse.decode(new _m0.Reader(data)) + ); + } + + search_cars_by_level( + request: SearchCarsByLevelRequest + ): Promise { + const data = SearchCarsByLevelRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "search_cars_by_level", + data + ); + return promise.then((data) => + SearchCarsByLevelResponse.decode(new _m0.Reader(data)) + ); + } + + load_paths_and_tunings( + request: LoadPathsAndTuningsRequest + ): Promise { + const data = LoadPathsAndTuningsRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_paths_and_tunings", + data + ); + return promise.then((data) => + LoadPathsAndTuningsResponse.decode(new _m0.Reader(data)) + ); + } + + load_ghost_drive_data( + request: LoadGhostDriveDataRequest + ): Promise { + const data = LoadGhostDriveDataRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "load_ghost_drive_data", + data + ); + return promise.then((data) => + LoadGhostDriveDataResponse.decode(new _m0.Reader(data)) + ); + } + + participate_in_invite_friend_campaign( + request: ParticipateInInviteFriendCampaignRequest + ): Promise { + const data = + ParticipateInInviteFriendCampaignRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "participate_in_invite_friend_campaign", + data + ); + return promise.then((data) => + ParticipateInInviteFriendCampaignResponse.decode(new _m0.Reader(data)) + ); + } + + lock_crown(request: LockCrownRequest): Promise { + const data = LockCrownRequest.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Rpc", "lock_crown", data); + return promise.then((data) => + LockCrownResponse.decode(new _m0.Reader(data)) + ); + } + + submit_client_log( + request: SubmitClientLogRequest + ): Promise { + const data = SubmitClientLogRequest.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Rpc", + "submit_client_log", + data + ); + return promise.then((data) => + SubmitClientLogResponse.decode(new _m0.Reader(data)) + ); + } +} + +export interface Resource { + ghost_trail(request: GhostTrailQuery): Promise; + place_list(request: PlaceListQuery): Promise; + ghost_list(request: GhostListQuery): Promise; + car_summary(request: CarSummaryQuery): Promise; + file_list(request: FileListQuery): Promise; + ghost_competition_target( + request: GhostCompetitionTargetQuery + ): Promise; + crown_list(request: CrownListQuery): Promise; + ranking(request: RankingQuery): Promise; +} + +export class ResourceClientImpl implements Resource { + private readonly rpc: _Rpc; + constructor(rpc: _Rpc) { + this.rpc = rpc; + this.ghost_trail = this.ghost_trail.bind(this); + this.place_list = this.place_list.bind(this); + this.ghost_list = this.ghost_list.bind(this); + this.car_summary = this.car_summary.bind(this); + this.file_list = this.file_list.bind(this); + this.ghost_competition_target = this.ghost_competition_target.bind(this); + this.crown_list = this.crown_list.bind(this); + this.ranking = this.ranking.bind(this); + } + ghost_trail(request: GhostTrailQuery): Promise { + const data = GhostTrailQuery.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Resource", + "ghost_trail", + data + ); + return promise.then((data) => GhostTrail.decode(new _m0.Reader(data))); + } + + place_list(request: PlaceListQuery): Promise { + const data = PlaceListQuery.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Resource", + "place_list", + data + ); + return promise.then((data) => PlaceList.decode(new _m0.Reader(data))); + } + + ghost_list(request: GhostListQuery): Promise { + const data = GhostListQuery.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Resource", + "ghost_list", + data + ); + return promise.then((data) => GhostList.decode(new _m0.Reader(data))); + } + + car_summary(request: CarSummaryQuery): Promise { + const data = CarSummaryQuery.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Resource", + "car_summary", + data + ); + return promise.then((data) => CarSummary.decode(new _m0.Reader(data))); + } + + file_list(request: FileListQuery): Promise { + const data = FileListQuery.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Resource", "file_list", data); + return promise.then((data) => FileList.decode(new _m0.Reader(data))); + } + + ghost_competition_target( + request: GhostCompetitionTargetQuery + ): Promise { + const data = GhostCompetitionTargetQuery.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Resource", + "ghost_competition_target", + data + ); + return promise.then((data) => + GhostCompetitionTarget.decode(new _m0.Reader(data)) + ); + } + + crown_list(request: CrownListQuery): Promise { + const data = CrownListQuery.encode(request).finish(); + const promise = this.rpc.request( + "wm.protobuf.Resource", + "crown_list", + data + ); + return promise.then((data) => CrownList.decode(new _m0.Reader(data))); + } + + ranking(request: RankingQuery): Promise { + const data = RankingQuery.encode(request).finish(); + const promise = this.rpc.request("wm.protobuf.Resource", "ranking", data); + return promise.then((data) => Ranking.decode(new _m0.Reader(data))); + } +} + +interface _Rpc { + request( + service: string, + method: string, + data: Uint8Array + ): Promise; +} + +declare var self: any | undefined; +declare var window: any | undefined; +declare var global: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + +type Builtin = + | Date + | Function + | Uint8Array + | string + | number + | boolean + | undefined; + +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +type KeysOfUnion = T extends T ? keyof T : never; +export type Exact = P extends Builtin + ? P + : P & { [K in keyof P]: Exact } & Record< + Exclude>, + never + >; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (_m0.util.Long !== Long) { + _m0.util.Long = Long as any; + _m0.configure(); +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} diff --git a/proto_src/system.ts b/proto_src/system.ts new file mode 100644 index 0000000..786f674 --- /dev/null +++ b/proto_src/system.ts @@ -0,0 +1,1085 @@ +/* eslint-disable */ +import { GameFeatureVersion } from "./wm"; +import * as _m0 from "protobufjs/minimal"; + +export const protobufPackage = "sys.protobuf"; + +export enum State { + State_None = 0, + State_Checking = 1, + State_NG = 2, + State_OK = 3, + UNRECOGNIZED = -1, +} + +export function stateFromJSON(object: any): State { + switch (object) { + case 0: + case "State_None": + return State.State_None; + case 1: + case "State_Checking": + return State.State_Checking; + case 2: + case "State_NG": + return State.State_NG; + case 3: + case "State_OK": + return State.State_OK; + case -1: + case "UNRECOGNIZED": + default: + return State.UNRECOGNIZED; + } +} + +export function stateToJSON(object: State): string { + switch (object) { + case State.State_None: + return "State_None"; + case State.State_Checking: + return "State_Checking"; + case State.State_NG: + return "State_NG"; + case State.State_OK: + return "State_OK"; + case State.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum BanaCoinPaymentState { + BC_SUCCESS = 0, + BC_SHORTAGE = 1, + BC_BNID_MEMBER_ERROR = 2, + BC_UNKNOWN_ERROR = 3, + BC_BNID_SYSTEM_ERROR = 4, + BC_BNID_VERIFY_ERROR = 5, + BC_BNID_EXECUTE_ERROR = 6, + BC_BNID_SERVER_UNAVAILABLE = 99, + UNRECOGNIZED = -1, +} + +export function banaCoinPaymentStateFromJSON( + object: any +): BanaCoinPaymentState { + switch (object) { + case 0: + case "BC_SUCCESS": + return BanaCoinPaymentState.BC_SUCCESS; + case 1: + case "BC_SHORTAGE": + return BanaCoinPaymentState.BC_SHORTAGE; + case 2: + case "BC_BNID_MEMBER_ERROR": + return BanaCoinPaymentState.BC_BNID_MEMBER_ERROR; + case 3: + case "BC_UNKNOWN_ERROR": + return BanaCoinPaymentState.BC_UNKNOWN_ERROR; + case 4: + case "BC_BNID_SYSTEM_ERROR": + return BanaCoinPaymentState.BC_BNID_SYSTEM_ERROR; + case 5: + case "BC_BNID_VERIFY_ERROR": + return BanaCoinPaymentState.BC_BNID_VERIFY_ERROR; + case 6: + case "BC_BNID_EXECUTE_ERROR": + return BanaCoinPaymentState.BC_BNID_EXECUTE_ERROR; + case 99: + case "BC_BNID_SERVER_UNAVAILABLE": + return BanaCoinPaymentState.BC_BNID_SERVER_UNAVAILABLE; + case -1: + case "UNRECOGNIZED": + default: + return BanaCoinPaymentState.UNRECOGNIZED; + } +} + +export function banaCoinPaymentStateToJSON( + object: BanaCoinPaymentState +): string { + switch (object) { + case BanaCoinPaymentState.BC_SUCCESS: + return "BC_SUCCESS"; + case BanaCoinPaymentState.BC_SHORTAGE: + return "BC_SHORTAGE"; + case BanaCoinPaymentState.BC_BNID_MEMBER_ERROR: + return "BC_BNID_MEMBER_ERROR"; + case BanaCoinPaymentState.BC_UNKNOWN_ERROR: + return "BC_UNKNOWN_ERROR"; + case BanaCoinPaymentState.BC_BNID_SYSTEM_ERROR: + return "BC_BNID_SYSTEM_ERROR"; + case BanaCoinPaymentState.BC_BNID_VERIFY_ERROR: + return "BC_BNID_VERIFY_ERROR"; + case BanaCoinPaymentState.BC_BNID_EXECUTE_ERROR: + return "BC_BNID_EXECUTE_ERROR"; + case BanaCoinPaymentState.BC_BNID_SERVER_UNAVAILABLE: + return "BC_BNID_SERVER_UNAVAILABLE"; + case BanaCoinPaymentState.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface Log { + errors: Log_Error[]; +} + +export interface Log_Error { + timestamp: number; + code: number; +} + +export interface BanaCoinPaymentLog { + payments: BanaCoinPaymentLog_Payment[]; +} + +export interface BanaCoinPaymentLog_Payment { + date: number; + contactNumber: string; + state: BanaCoinPaymentState; + cost: number; + accessCode: string; + personId: string; +} + +export interface Operation { + authorizationAt: number; + featureVersion: GameFeatureVersion | undefined; +} + +export interface Status { + state: State; + name: string; + address: number; + value: number; + value2: number; +} + +export interface Command { + sequence: number; + ntp: string; + checkCable: string; + renewDhcp: string; + setDate: number; + syncDate: string; + ping: number[]; + traceRoute: number; + checkPacket: string; + reboot: string; + checkPkg: string; +} + +export interface Reply { + sequence: number; + ntp: Status | undefined; + checkCable: Status | undefined; + renewDhcp: Status | undefined; + setDate: Status | undefined; + syncDate: Status | undefined; + ping: Status[]; + traceRoute: Status | undefined; + checkPacket: Status | undefined; + reboot: Status | undefined; + checkPkg: Status | undefined; +} + +function createBaseLog(): Log { + return { errors: [] }; +} + +export const Log = { + encode(message: Log, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + for (const v of message.errors) { + Log_Error.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Log { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLog(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.errors.push(Log_Error.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Log { + return { + errors: Array.isArray(object?.errors) + ? object.errors.map((e: any) => Log_Error.fromJSON(e)) + : [], + }; + }, + + toJSON(message: Log): unknown { + const obj: any = {}; + if (message.errors) { + obj.errors = message.errors.map((e) => + e ? Log_Error.toJSON(e) : undefined + ); + } else { + obj.errors = []; + } + return obj; + }, + + fromPartial, I>>(object: I): Log { + const message = createBaseLog(); + message.errors = object.errors?.map((e) => Log_Error.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseLog_Error(): Log_Error { + return { timestamp: 0, code: 0 }; +} + +export const Log_Error = { + encode( + message: Log_Error, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.timestamp !== 0) { + writer.uint32(8).uint32(message.timestamp); + } + if (message.code !== 0) { + writer.uint32(16).uint32(message.code); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Log_Error { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLog_Error(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.timestamp = reader.uint32(); + break; + case 2: + message.code = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Log_Error { + return { + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + code: isSet(object.code) ? Number(object.code) : 0, + }; + }, + + toJSON(message: Log_Error): unknown { + const obj: any = {}; + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + message.code !== undefined && (obj.code = Math.round(message.code)); + return obj; + }, + + fromPartial, I>>( + object: I + ): Log_Error { + const message = createBaseLog_Error(); + message.timestamp = object.timestamp ?? 0; + message.code = object.code ?? 0; + return message; + }, +}; + +function createBaseBanaCoinPaymentLog(): BanaCoinPaymentLog { + return { payments: [] }; +} + +export const BanaCoinPaymentLog = { + encode( + message: BanaCoinPaymentLog, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.payments) { + BanaCoinPaymentLog_Payment.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): BanaCoinPaymentLog { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBanaCoinPaymentLog(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.payments.push( + BanaCoinPaymentLog_Payment.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): BanaCoinPaymentLog { + return { + payments: Array.isArray(object?.payments) + ? object.payments.map((e: any) => + BanaCoinPaymentLog_Payment.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: BanaCoinPaymentLog): unknown { + const obj: any = {}; + if (message.payments) { + obj.payments = message.payments.map((e) => + e ? BanaCoinPaymentLog_Payment.toJSON(e) : undefined + ); + } else { + obj.payments = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): BanaCoinPaymentLog { + const message = createBaseBanaCoinPaymentLog(); + message.payments = + object.payments?.map((e) => BanaCoinPaymentLog_Payment.fromPartial(e)) || + []; + return message; + }, +}; + +function createBaseBanaCoinPaymentLog_Payment(): BanaCoinPaymentLog_Payment { + return { + date: 0, + contactNumber: "", + state: 0, + cost: 0, + accessCode: "", + personId: "", + }; +} + +export const BanaCoinPaymentLog_Payment = { + encode( + message: BanaCoinPaymentLog_Payment, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.date !== 0) { + writer.uint32(8).uint32(message.date); + } + if (message.contactNumber !== "") { + writer.uint32(18).string(message.contactNumber); + } + if (message.state !== 0) { + writer.uint32(24).int32(message.state); + } + if (message.cost !== 0) { + writer.uint32(32).uint32(message.cost); + } + if (message.accessCode !== "") { + writer.uint32(50).string(message.accessCode); + } + if (message.personId !== "") { + writer.uint32(58).string(message.personId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): BanaCoinPaymentLog_Payment { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBanaCoinPaymentLog_Payment(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.date = reader.uint32(); + break; + case 2: + message.contactNumber = reader.string(); + break; + case 3: + message.state = reader.int32() as any; + break; + case 4: + message.cost = reader.uint32(); + break; + case 6: + message.accessCode = reader.string(); + break; + case 7: + message.personId = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): BanaCoinPaymentLog_Payment { + return { + date: isSet(object.date) ? Number(object.date) : 0, + contactNumber: isSet(object.contactNumber) + ? String(object.contactNumber) + : "", + state: isSet(object.state) + ? banaCoinPaymentStateFromJSON(object.state) + : 0, + cost: isSet(object.cost) ? Number(object.cost) : 0, + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + personId: isSet(object.personId) ? String(object.personId) : "", + }; + }, + + toJSON(message: BanaCoinPaymentLog_Payment): unknown { + const obj: any = {}; + message.date !== undefined && (obj.date = Math.round(message.date)); + message.contactNumber !== undefined && + (obj.contactNumber = message.contactNumber); + message.state !== undefined && + (obj.state = banaCoinPaymentStateToJSON(message.state)); + message.cost !== undefined && (obj.cost = Math.round(message.cost)); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.personId !== undefined && (obj.personId = message.personId); + return obj; + }, + + fromPartial, I>>( + object: I + ): BanaCoinPaymentLog_Payment { + const message = createBaseBanaCoinPaymentLog_Payment(); + message.date = object.date ?? 0; + message.contactNumber = object.contactNumber ?? ""; + message.state = object.state ?? 0; + message.cost = object.cost ?? 0; + message.accessCode = object.accessCode ?? ""; + message.personId = object.personId ?? ""; + return message; + }, +}; + +function createBaseOperation(): Operation { + return { authorizationAt: 0, featureVersion: undefined }; +} + +export const Operation = { + encode( + message: Operation, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.authorizationAt !== 0) { + writer.uint32(8).uint32(message.authorizationAt); + } + if (message.featureVersion !== undefined) { + GameFeatureVersion.encode( + message.featureVersion, + writer.uint32(18).fork() + ).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Operation { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOperation(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.authorizationAt = reader.uint32(); + break; + case 2: + message.featureVersion = GameFeatureVersion.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Operation { + return { + authorizationAt: isSet(object.authorizationAt) + ? Number(object.authorizationAt) + : 0, + featureVersion: isSet(object.featureVersion) + ? GameFeatureVersion.fromJSON(object.featureVersion) + : undefined, + }; + }, + + toJSON(message: Operation): unknown { + const obj: any = {}; + message.authorizationAt !== undefined && + (obj.authorizationAt = Math.round(message.authorizationAt)); + message.featureVersion !== undefined && + (obj.featureVersion = message.featureVersion + ? GameFeatureVersion.toJSON(message.featureVersion) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): Operation { + const message = createBaseOperation(); + message.authorizationAt = object.authorizationAt ?? 0; + message.featureVersion = + object.featureVersion !== undefined && object.featureVersion !== null + ? GameFeatureVersion.fromPartial(object.featureVersion) + : undefined; + return message; + }, +}; + +function createBaseStatus(): Status { + return { state: 0, name: "", address: 0, value: 0, value2: 0 }; +} + +export const Status = { + encode( + message: Status, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.state !== 0) { + writer.uint32(8).int32(message.state); + } + if (message.name !== "") { + writer.uint32(18).string(message.name); + } + if (message.address !== 0) { + writer.uint32(24).uint32(message.address); + } + if (message.value !== 0) { + writer.uint32(32).int32(message.value); + } + if (message.value2 !== 0) { + writer.uint32(40).int32(message.value2); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Status { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStatus(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.state = reader.int32() as any; + break; + case 2: + message.name = reader.string(); + break; + case 3: + message.address = reader.uint32(); + break; + case 4: + message.value = reader.int32(); + break; + case 5: + message.value2 = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Status { + return { + state: isSet(object.state) ? stateFromJSON(object.state) : 0, + name: isSet(object.name) ? String(object.name) : "", + address: isSet(object.address) ? Number(object.address) : 0, + value: isSet(object.value) ? Number(object.value) : 0, + value2: isSet(object.value2) ? Number(object.value2) : 0, + }; + }, + + toJSON(message: Status): unknown { + const obj: any = {}; + message.state !== undefined && (obj.state = stateToJSON(message.state)); + message.name !== undefined && (obj.name = message.name); + message.address !== undefined && + (obj.address = Math.round(message.address)); + message.value !== undefined && (obj.value = Math.round(message.value)); + message.value2 !== undefined && (obj.value2 = Math.round(message.value2)); + return obj; + }, + + fromPartial, I>>(object: I): Status { + const message = createBaseStatus(); + message.state = object.state ?? 0; + message.name = object.name ?? ""; + message.address = object.address ?? 0; + message.value = object.value ?? 0; + message.value2 = object.value2 ?? 0; + return message; + }, +}; + +function createBaseCommand(): Command { + return { + sequence: 0, + ntp: "", + checkCable: "", + renewDhcp: "", + setDate: 0, + syncDate: "", + ping: [], + traceRoute: 0, + checkPacket: "", + reboot: "", + checkPkg: "", + }; +} + +export const Command = { + encode( + message: Command, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.sequence !== 0) { + writer.uint32(8).uint32(message.sequence); + } + if (message.ntp !== "") { + writer.uint32(18).string(message.ntp); + } + if (message.checkCable !== "") { + writer.uint32(26).string(message.checkCable); + } + if (message.renewDhcp !== "") { + writer.uint32(34).string(message.renewDhcp); + } + if (message.setDate !== 0) { + writer.uint32(40).uint32(message.setDate); + } + if (message.syncDate !== "") { + writer.uint32(50).string(message.syncDate); + } + writer.uint32(58).fork(); + for (const v of message.ping) { + writer.uint32(v); + } + writer.ldelim(); + if (message.traceRoute !== 0) { + writer.uint32(64).uint32(message.traceRoute); + } + if (message.checkPacket !== "") { + writer.uint32(74).string(message.checkPacket); + } + if (message.reboot !== "") { + writer.uint32(82).string(message.reboot); + } + if (message.checkPkg !== "") { + writer.uint32(90).string(message.checkPkg); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Command { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCommand(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.sequence = reader.uint32(); + break; + case 2: + message.ntp = reader.string(); + break; + case 3: + message.checkCable = reader.string(); + break; + case 4: + message.renewDhcp = reader.string(); + break; + case 5: + message.setDate = reader.uint32(); + break; + case 6: + message.syncDate = reader.string(); + break; + case 7: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.ping.push(reader.uint32()); + } + } else { + message.ping.push(reader.uint32()); + } + break; + case 8: + message.traceRoute = reader.uint32(); + break; + case 9: + message.checkPacket = reader.string(); + break; + case 10: + message.reboot = reader.string(); + break; + case 11: + message.checkPkg = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Command { + return { + sequence: isSet(object.sequence) ? Number(object.sequence) : 0, + ntp: isSet(object.ntp) ? String(object.ntp) : "", + checkCable: isSet(object.checkCable) ? String(object.checkCable) : "", + renewDhcp: isSet(object.renewDhcp) ? String(object.renewDhcp) : "", + setDate: isSet(object.setDate) ? Number(object.setDate) : 0, + syncDate: isSet(object.syncDate) ? String(object.syncDate) : "", + ping: Array.isArray(object?.ping) + ? object.ping.map((e: any) => Number(e)) + : [], + traceRoute: isSet(object.traceRoute) ? Number(object.traceRoute) : 0, + checkPacket: isSet(object.checkPacket) ? String(object.checkPacket) : "", + reboot: isSet(object.reboot) ? String(object.reboot) : "", + checkPkg: isSet(object.checkPkg) ? String(object.checkPkg) : "", + }; + }, + + toJSON(message: Command): unknown { + const obj: any = {}; + message.sequence !== undefined && + (obj.sequence = Math.round(message.sequence)); + message.ntp !== undefined && (obj.ntp = message.ntp); + message.checkCable !== undefined && (obj.checkCable = message.checkCable); + message.renewDhcp !== undefined && (obj.renewDhcp = message.renewDhcp); + message.setDate !== undefined && + (obj.setDate = Math.round(message.setDate)); + message.syncDate !== undefined && (obj.syncDate = message.syncDate); + if (message.ping) { + obj.ping = message.ping.map((e) => Math.round(e)); + } else { + obj.ping = []; + } + message.traceRoute !== undefined && + (obj.traceRoute = Math.round(message.traceRoute)); + message.checkPacket !== undefined && + (obj.checkPacket = message.checkPacket); + message.reboot !== undefined && (obj.reboot = message.reboot); + message.checkPkg !== undefined && (obj.checkPkg = message.checkPkg); + return obj; + }, + + fromPartial, I>>(object: I): Command { + const message = createBaseCommand(); + message.sequence = object.sequence ?? 0; + message.ntp = object.ntp ?? ""; + message.checkCable = object.checkCable ?? ""; + message.renewDhcp = object.renewDhcp ?? ""; + message.setDate = object.setDate ?? 0; + message.syncDate = object.syncDate ?? ""; + message.ping = object.ping?.map((e) => e) || []; + message.traceRoute = object.traceRoute ?? 0; + message.checkPacket = object.checkPacket ?? ""; + message.reboot = object.reboot ?? ""; + message.checkPkg = object.checkPkg ?? ""; + return message; + }, +}; + +function createBaseReply(): Reply { + return { + sequence: 0, + ntp: undefined, + checkCable: undefined, + renewDhcp: undefined, + setDate: undefined, + syncDate: undefined, + ping: [], + traceRoute: undefined, + checkPacket: undefined, + reboot: undefined, + checkPkg: undefined, + }; +} + +export const Reply = { + encode(message: Reply, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.sequence !== 0) { + writer.uint32(8).uint32(message.sequence); + } + if (message.ntp !== undefined) { + Status.encode(message.ntp, writer.uint32(18).fork()).ldelim(); + } + if (message.checkCable !== undefined) { + Status.encode(message.checkCable, writer.uint32(26).fork()).ldelim(); + } + if (message.renewDhcp !== undefined) { + Status.encode(message.renewDhcp, writer.uint32(34).fork()).ldelim(); + } + if (message.setDate !== undefined) { + Status.encode(message.setDate, writer.uint32(42).fork()).ldelim(); + } + if (message.syncDate !== undefined) { + Status.encode(message.syncDate, writer.uint32(50).fork()).ldelim(); + } + for (const v of message.ping) { + Status.encode(v!, writer.uint32(58).fork()).ldelim(); + } + if (message.traceRoute !== undefined) { + Status.encode(message.traceRoute, writer.uint32(66).fork()).ldelim(); + } + if (message.checkPacket !== undefined) { + Status.encode(message.checkPacket, writer.uint32(74).fork()).ldelim(); + } + if (message.reboot !== undefined) { + Status.encode(message.reboot, writer.uint32(82).fork()).ldelim(); + } + if (message.checkPkg !== undefined) { + Status.encode(message.checkPkg, writer.uint32(90).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Reply { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseReply(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.sequence = reader.uint32(); + break; + case 2: + message.ntp = Status.decode(reader, reader.uint32()); + break; + case 3: + message.checkCable = Status.decode(reader, reader.uint32()); + break; + case 4: + message.renewDhcp = Status.decode(reader, reader.uint32()); + break; + case 5: + message.setDate = Status.decode(reader, reader.uint32()); + break; + case 6: + message.syncDate = Status.decode(reader, reader.uint32()); + break; + case 7: + message.ping.push(Status.decode(reader, reader.uint32())); + break; + case 8: + message.traceRoute = Status.decode(reader, reader.uint32()); + break; + case 9: + message.checkPacket = Status.decode(reader, reader.uint32()); + break; + case 10: + message.reboot = Status.decode(reader, reader.uint32()); + break; + case 11: + message.checkPkg = Status.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Reply { + return { + sequence: isSet(object.sequence) ? Number(object.sequence) : 0, + ntp: isSet(object.ntp) ? Status.fromJSON(object.ntp) : undefined, + checkCable: isSet(object.checkCable) + ? Status.fromJSON(object.checkCable) + : undefined, + renewDhcp: isSet(object.renewDhcp) + ? Status.fromJSON(object.renewDhcp) + : undefined, + setDate: isSet(object.setDate) + ? Status.fromJSON(object.setDate) + : undefined, + syncDate: isSet(object.syncDate) + ? Status.fromJSON(object.syncDate) + : undefined, + ping: Array.isArray(object?.ping) + ? object.ping.map((e: any) => Status.fromJSON(e)) + : [], + traceRoute: isSet(object.traceRoute) + ? Status.fromJSON(object.traceRoute) + : undefined, + checkPacket: isSet(object.checkPacket) + ? Status.fromJSON(object.checkPacket) + : undefined, + reboot: isSet(object.reboot) ? Status.fromJSON(object.reboot) : undefined, + checkPkg: isSet(object.checkPkg) + ? Status.fromJSON(object.checkPkg) + : undefined, + }; + }, + + toJSON(message: Reply): unknown { + const obj: any = {}; + message.sequence !== undefined && + (obj.sequence = Math.round(message.sequence)); + message.ntp !== undefined && + (obj.ntp = message.ntp ? Status.toJSON(message.ntp) : undefined); + message.checkCable !== undefined && + (obj.checkCable = message.checkCable + ? Status.toJSON(message.checkCable) + : undefined); + message.renewDhcp !== undefined && + (obj.renewDhcp = message.renewDhcp + ? Status.toJSON(message.renewDhcp) + : undefined); + message.setDate !== undefined && + (obj.setDate = message.setDate + ? Status.toJSON(message.setDate) + : undefined); + message.syncDate !== undefined && + (obj.syncDate = message.syncDate + ? Status.toJSON(message.syncDate) + : undefined); + if (message.ping) { + obj.ping = message.ping.map((e) => (e ? Status.toJSON(e) : undefined)); + } else { + obj.ping = []; + } + message.traceRoute !== undefined && + (obj.traceRoute = message.traceRoute + ? Status.toJSON(message.traceRoute) + : undefined); + message.checkPacket !== undefined && + (obj.checkPacket = message.checkPacket + ? Status.toJSON(message.checkPacket) + : undefined); + message.reboot !== undefined && + (obj.reboot = message.reboot ? Status.toJSON(message.reboot) : undefined); + message.checkPkg !== undefined && + (obj.checkPkg = message.checkPkg + ? Status.toJSON(message.checkPkg) + : undefined); + return obj; + }, + + fromPartial, I>>(object: I): Reply { + const message = createBaseReply(); + message.sequence = object.sequence ?? 0; + message.ntp = + object.ntp !== undefined && object.ntp !== null + ? Status.fromPartial(object.ntp) + : undefined; + message.checkCable = + object.checkCable !== undefined && object.checkCable !== null + ? Status.fromPartial(object.checkCable) + : undefined; + message.renewDhcp = + object.renewDhcp !== undefined && object.renewDhcp !== null + ? Status.fromPartial(object.renewDhcp) + : undefined; + message.setDate = + object.setDate !== undefined && object.setDate !== null + ? Status.fromPartial(object.setDate) + : undefined; + message.syncDate = + object.syncDate !== undefined && object.syncDate !== null + ? Status.fromPartial(object.syncDate) + : undefined; + message.ping = object.ping?.map((e) => Status.fromPartial(e)) || []; + message.traceRoute = + object.traceRoute !== undefined && object.traceRoute !== null + ? Status.fromPartial(object.traceRoute) + : undefined; + message.checkPacket = + object.checkPacket !== undefined && object.checkPacket !== null + ? Status.fromPartial(object.checkPacket) + : undefined; + message.reboot = + object.reboot !== undefined && object.reboot !== null + ? Status.fromPartial(object.reboot) + : undefined; + message.checkPkg = + object.checkPkg !== undefined && object.checkPkg !== null + ? Status.fromPartial(object.checkPkg) + : undefined; + return message; + }, +}; + +type Builtin = + | Date + | Function + | Uint8Array + | string + | number + | boolean + | undefined; + +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +type KeysOfUnion = T extends T ? keyof T : never; +export type Exact = P extends Builtin + ? P + : P & { [K in keyof P]: Exact } & Record< + Exclude>, + never + >; + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} diff --git a/proto_src/wm.ts b/proto_src/wm.ts new file mode 100644 index 0000000..7f44abf --- /dev/null +++ b/proto_src/wm.ts @@ -0,0 +1,19915 @@ +/* eslint-disable */ +import Long from "long"; +import * as _m0 from "protobufjs/minimal"; + +export const protobufPackage = "wm.protobuf"; + +export enum SystemConstant { + PROTOBUF_MESSAGE_REVISION = 8053, + UNRECOGNIZED = -1, +} + +export function systemConstantFromJSON(object: any): SystemConstant { + switch (object) { + case 8053: + case "PROTOBUF_MESSAGE_REVISION": + return SystemConstant.PROTOBUF_MESSAGE_REVISION; + case -1: + case "UNRECOGNIZED": + default: + return SystemConstant.UNRECOGNIZED; + } +} + +export function systemConstantToJSON(object: SystemConstant): string { + switch (object) { + case SystemConstant.PROTOBUF_MESSAGE_REVISION: + return "PROTOBUF_MESSAGE_REVISION"; + case SystemConstant.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum ErrorCode { + ERR_SUCCESS = 0, + ERR_REQUEST = 1, + ERR_NOT_FOUND = 2, + ERR_ID_SERVER = 3, + ERR_ID_BANNED = 4, + ERR_USER_LOCKED = 5, + ERR_USER_VERSION = 6, + ERR_NAME_CONFLICTED = 7, + ERR_FORBIDDEN = 9, + ERR_USER_SUCCEEDED = 11, + ERR_BEING_TRANSFERRED = 12, + ERR_SCRATCH_LOCKED = 13, + UNRECOGNIZED = -1, +} + +export function errorCodeFromJSON(object: any): ErrorCode { + switch (object) { + case 0: + case "ERR_SUCCESS": + return ErrorCode.ERR_SUCCESS; + case 1: + case "ERR_REQUEST": + return ErrorCode.ERR_REQUEST; + case 2: + case "ERR_NOT_FOUND": + return ErrorCode.ERR_NOT_FOUND; + case 3: + case "ERR_ID_SERVER": + return ErrorCode.ERR_ID_SERVER; + case 4: + case "ERR_ID_BANNED": + return ErrorCode.ERR_ID_BANNED; + case 5: + case "ERR_USER_LOCKED": + return ErrorCode.ERR_USER_LOCKED; + case 6: + case "ERR_USER_VERSION": + return ErrorCode.ERR_USER_VERSION; + case 7: + case "ERR_NAME_CONFLICTED": + return ErrorCode.ERR_NAME_CONFLICTED; + case 9: + case "ERR_FORBIDDEN": + return ErrorCode.ERR_FORBIDDEN; + case 11: + case "ERR_USER_SUCCEEDED": + return ErrorCode.ERR_USER_SUCCEEDED; + case 12: + case "ERR_BEING_TRANSFERRED": + return ErrorCode.ERR_BEING_TRANSFERRED; + case 13: + case "ERR_SCRATCH_LOCKED": + return ErrorCode.ERR_SCRATCH_LOCKED; + case -1: + case "UNRECOGNIZED": + default: + return ErrorCode.UNRECOGNIZED; + } +} + +export function errorCodeToJSON(object: ErrorCode): string { + switch (object) { + case ErrorCode.ERR_SUCCESS: + return "ERR_SUCCESS"; + case ErrorCode.ERR_REQUEST: + return "ERR_REQUEST"; + case ErrorCode.ERR_NOT_FOUND: + return "ERR_NOT_FOUND"; + case ErrorCode.ERR_ID_SERVER: + return "ERR_ID_SERVER"; + case ErrorCode.ERR_ID_BANNED: + return "ERR_ID_BANNED"; + case ErrorCode.ERR_USER_LOCKED: + return "ERR_USER_LOCKED"; + case ErrorCode.ERR_USER_VERSION: + return "ERR_USER_VERSION"; + case ErrorCode.ERR_NAME_CONFLICTED: + return "ERR_NAME_CONFLICTED"; + case ErrorCode.ERR_FORBIDDEN: + return "ERR_FORBIDDEN"; + case ErrorCode.ERR_USER_SUCCEEDED: + return "ERR_USER_SUCCEEDED"; + case ErrorCode.ERR_BEING_TRANSFERRED: + return "ERR_BEING_TRANSFERRED"; + case ErrorCode.ERR_SCRATCH_LOCKED: + return "ERR_SCRATCH_LOCKED"; + case ErrorCode.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum LineType { + L_UNKNOWN = 0, + L_MOBILE = 1, + L_ISDN = 2, + L_BFLETS = 3, + L_ADSL = 4, + L_WIRED = 5, + UNRECOGNIZED = -1, +} + +export function lineTypeFromJSON(object: any): LineType { + switch (object) { + case 0: + case "L_UNKNOWN": + return LineType.L_UNKNOWN; + case 1: + case "L_MOBILE": + return LineType.L_MOBILE; + case 2: + case "L_ISDN": + return LineType.L_ISDN; + case 3: + case "L_BFLETS": + return LineType.L_BFLETS; + case 4: + case "L_ADSL": + return LineType.L_ADSL; + case 5: + case "L_WIRED": + return LineType.L_WIRED; + case -1: + case "UNRECOGNIZED": + default: + return LineType.UNRECOGNIZED; + } +} + +export function lineTypeToJSON(object: LineType): string { + switch (object) { + case LineType.L_UNKNOWN: + return "L_UNKNOWN"; + case LineType.L_MOBILE: + return "L_MOBILE"; + case LineType.L_ISDN: + return "L_ISDN"; + case LineType.L_BFLETS: + return "L_BFLETS"; + case LineType.L_ADSL: + return "L_ADSL"; + case LineType.L_WIRED: + return "L_WIRED"; + case LineType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum TerminalType { + T_DRIVE = 0, + T_TERMINAL = 1, + UNRECOGNIZED = -1, +} + +export function terminalTypeFromJSON(object: any): TerminalType { + switch (object) { + case 0: + case "T_DRIVE": + return TerminalType.T_DRIVE; + case 1: + case "T_TERMINAL": + return TerminalType.T_TERMINAL; + case -1: + case "UNRECOGNIZED": + default: + return TerminalType.UNRECOGNIZED; + } +} + +export function terminalTypeToJSON(object: TerminalType): string { + switch (object) { + case TerminalType.T_DRIVE: + return "T_DRIVE"; + case TerminalType.T_TERMINAL: + return "T_TERMINAL"; + case TerminalType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum DeviceType { + DEVICE_CARD = 0, + DEVICE_PHONE = 1, + UNRECOGNIZED = -1, +} + +export function deviceTypeFromJSON(object: any): DeviceType { + switch (object) { + case 0: + case "DEVICE_CARD": + return DeviceType.DEVICE_CARD; + case 1: + case "DEVICE_PHONE": + return DeviceType.DEVICE_PHONE; + case -1: + case "UNRECOGNIZED": + default: + return DeviceType.UNRECOGNIZED; + } +} + +export function deviceTypeToJSON(object: DeviceType): string { + switch (object) { + case DeviceType.DEVICE_CARD: + return "DEVICE_CARD"; + case DeviceType.DEVICE_PHONE: + return "DEVICE_PHONE"; + case DeviceType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum ItemCategory { + CAT_CUSTOM_COLOR = 1, + CAT_WHEEL = 2, + CAT_AERO = 3, + CAT_BONNET = 4, + CAT_WING = 5, + CAT_MIRROR = 6, + CAT_NEON = 8, + CAT_TRUNK = 9, + CAT_NUMBER_PLATE = 10, + CAT_GT_WING = 12, + CAT_AURA_MOTIF = 14, + CAT_METER = 15, + CAT_BGM = 16, + CAT_NAME_PLATE = 17, + CAT_NUMBER = 19, + CAT_BGM_TRACK = 22, + CAT_WINDOW_STICKER_FONT = 24, + CAT_WINDOW_DECORATION = 25, + CAT_RIVAL_MARKER = 26, + CAT_STAMP = 27, + CAT_TERMINAL_BACKGROUND = 28, + CAT_CAR_TICKET = 201, + CAT_CONSUMPTION_ITEM = 202, + CAT_CAR_TICKET_FREE = 203, + CAT_AERO_FULLSET = 300, + CAT_AERO_LIMITED = 301, + UNRECOGNIZED = -1, +} + +export function itemCategoryFromJSON(object: any): ItemCategory { + switch (object) { + case 1: + case "CAT_CUSTOM_COLOR": + return ItemCategory.CAT_CUSTOM_COLOR; + case 2: + case "CAT_WHEEL": + return ItemCategory.CAT_WHEEL; + case 3: + case "CAT_AERO": + return ItemCategory.CAT_AERO; + case 4: + case "CAT_BONNET": + return ItemCategory.CAT_BONNET; + case 5: + case "CAT_WING": + return ItemCategory.CAT_WING; + case 6: + case "CAT_MIRROR": + return ItemCategory.CAT_MIRROR; + case 8: + case "CAT_NEON": + return ItemCategory.CAT_NEON; + case 9: + case "CAT_TRUNK": + return ItemCategory.CAT_TRUNK; + case 10: + case "CAT_NUMBER_PLATE": + return ItemCategory.CAT_NUMBER_PLATE; + case 12: + case "CAT_GT_WING": + return ItemCategory.CAT_GT_WING; + case 14: + case "CAT_AURA_MOTIF": + return ItemCategory.CAT_AURA_MOTIF; + case 15: + case "CAT_METER": + return ItemCategory.CAT_METER; + case 16: + case "CAT_BGM": + return ItemCategory.CAT_BGM; + case 17: + case "CAT_NAME_PLATE": + return ItemCategory.CAT_NAME_PLATE; + case 19: + case "CAT_NUMBER": + return ItemCategory.CAT_NUMBER; + case 22: + case "CAT_BGM_TRACK": + return ItemCategory.CAT_BGM_TRACK; + case 24: + case "CAT_WINDOW_STICKER_FONT": + return ItemCategory.CAT_WINDOW_STICKER_FONT; + case 25: + case "CAT_WINDOW_DECORATION": + return ItemCategory.CAT_WINDOW_DECORATION; + case 26: + case "CAT_RIVAL_MARKER": + return ItemCategory.CAT_RIVAL_MARKER; + case 27: + case "CAT_STAMP": + return ItemCategory.CAT_STAMP; + case 28: + case "CAT_TERMINAL_BACKGROUND": + return ItemCategory.CAT_TERMINAL_BACKGROUND; + case 201: + case "CAT_CAR_TICKET": + return ItemCategory.CAT_CAR_TICKET; + case 202: + case "CAT_CONSUMPTION_ITEM": + return ItemCategory.CAT_CONSUMPTION_ITEM; + case 203: + case "CAT_CAR_TICKET_FREE": + return ItemCategory.CAT_CAR_TICKET_FREE; + case 300: + case "CAT_AERO_FULLSET": + return ItemCategory.CAT_AERO_FULLSET; + case 301: + case "CAT_AERO_LIMITED": + return ItemCategory.CAT_AERO_LIMITED; + case -1: + case "UNRECOGNIZED": + default: + return ItemCategory.UNRECOGNIZED; + } +} + +export function itemCategoryToJSON(object: ItemCategory): string { + switch (object) { + case ItemCategory.CAT_CUSTOM_COLOR: + return "CAT_CUSTOM_COLOR"; + case ItemCategory.CAT_WHEEL: + return "CAT_WHEEL"; + case ItemCategory.CAT_AERO: + return "CAT_AERO"; + case ItemCategory.CAT_BONNET: + return "CAT_BONNET"; + case ItemCategory.CAT_WING: + return "CAT_WING"; + case ItemCategory.CAT_MIRROR: + return "CAT_MIRROR"; + case ItemCategory.CAT_NEON: + return "CAT_NEON"; + case ItemCategory.CAT_TRUNK: + return "CAT_TRUNK"; + case ItemCategory.CAT_NUMBER_PLATE: + return "CAT_NUMBER_PLATE"; + case ItemCategory.CAT_GT_WING: + return "CAT_GT_WING"; + case ItemCategory.CAT_AURA_MOTIF: + return "CAT_AURA_MOTIF"; + case ItemCategory.CAT_METER: + return "CAT_METER"; + case ItemCategory.CAT_BGM: + return "CAT_BGM"; + case ItemCategory.CAT_NAME_PLATE: + return "CAT_NAME_PLATE"; + case ItemCategory.CAT_NUMBER: + return "CAT_NUMBER"; + case ItemCategory.CAT_BGM_TRACK: + return "CAT_BGM_TRACK"; + case ItemCategory.CAT_WINDOW_STICKER_FONT: + return "CAT_WINDOW_STICKER_FONT"; + case ItemCategory.CAT_WINDOW_DECORATION: + return "CAT_WINDOW_DECORATION"; + case ItemCategory.CAT_RIVAL_MARKER: + return "CAT_RIVAL_MARKER"; + case ItemCategory.CAT_STAMP: + return "CAT_STAMP"; + case ItemCategory.CAT_TERMINAL_BACKGROUND: + return "CAT_TERMINAL_BACKGROUND"; + case ItemCategory.CAT_CAR_TICKET: + return "CAT_CAR_TICKET"; + case ItemCategory.CAT_CONSUMPTION_ITEM: + return "CAT_CONSUMPTION_ITEM"; + case ItemCategory.CAT_CAR_TICKET_FREE: + return "CAT_CAR_TICKET_FREE"; + case ItemCategory.CAT_AERO_FULLSET: + return "CAT_AERO_FULLSET"; + case ItemCategory.CAT_AERO_LIMITED: + return "CAT_AERO_LIMITED"; + case ItemCategory.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum TutorialType { + TUTORIAL_ID_STORY = 0, + TUTORIAL_ID_TIME_ATTACK = 1, + TUTORIAL_ID_GHOST = 2, + TUTORIAL_ID_GHOST_CHALLENGE = 3, + TUTORIAL_ID_GHOST_LEVEL = 4, + TUTORIAL_ID_UNUSED_5 = 5, + TUTORIAL_ID_GHOST_SEARCH = 6, + TUTORIAL_ID_GHOST_COMPETITION = 7, + TUTORIAL_ID_HP600_CARD = 8, + TUTORIAL_ID_UNUSED_9 = 9, + TUTORIAL_ID_COMPETITION_QUALIFIED = 10, + TUTORIAL_ID_COMPETITION_TERMINAL = 11, + TUTORIAL_ID_COMPETITION_NOTICE = 12, + TUTORIAL_ID_COMPETITION_FINISHED = 13, + TUTORIAL_ID_UNUSED_14 = 14, + TUTORIAL_ID_UNUSED_15 = 15, + TUTORIAL_ID_UNUSED_16 = 16, + TUTORIAL_ID_UNUSED_17 = 17, + TUTORIAL_ID_UNUSED_18 = 18, + TUTORIAL_ID_UNUSED_19 = 19, + TUTORIAL_ID_GHOST_STAMP = 20, + TUTORIAL_ID_GHOST_STAMP_DECLINED = 21, + TUTORIAL_ID_GHOST_STAMP_FRIENDS = 22, + TUTORIAL_ID_TERMINAL_SCRATCH = 23, + TUTORIAL_ID_TURN_SCRATCH_SHEET = 24, + TUTORIAL_ID_INVITE_FRIEND_CAMPAIGN = 25, + TUTORIAL_ID_CAR_COUPON_FULL_TUNED_RECEIVABLE = 26, + TUTORIAL_ID_VS_CONTINUE_TICKET = 27, + TUTORIAL_ID_UNUSED_28 = 28, + TUTORIAL_ID_UNUSED_29 = 29, + TUTORIAL_ID_UNUSED_30 = 30, + TUTORIAL_ID_DRESS_UP = 31, + TUTORIAL_ID_MULTI_GHOST = 32, + TUTORIAL_ID_STORY_NEW_FEATURE = 33, + TUTORIAL_ID_GHOST_NEW_FEATURE = 34, + TUTORIAL_ID_GHOST_REGION_MAP = 35, + UNRECOGNIZED = -1, +} + +export function tutorialTypeFromJSON(object: any): TutorialType { + switch (object) { + case 0: + case "TUTORIAL_ID_STORY": + return TutorialType.TUTORIAL_ID_STORY; + case 1: + case "TUTORIAL_ID_TIME_ATTACK": + return TutorialType.TUTORIAL_ID_TIME_ATTACK; + case 2: + case "TUTORIAL_ID_GHOST": + return TutorialType.TUTORIAL_ID_GHOST; + case 3: + case "TUTORIAL_ID_GHOST_CHALLENGE": + return TutorialType.TUTORIAL_ID_GHOST_CHALLENGE; + case 4: + case "TUTORIAL_ID_GHOST_LEVEL": + return TutorialType.TUTORIAL_ID_GHOST_LEVEL; + case 5: + case "TUTORIAL_ID_UNUSED_5": + return TutorialType.TUTORIAL_ID_UNUSED_5; + case 6: + case "TUTORIAL_ID_GHOST_SEARCH": + return TutorialType.TUTORIAL_ID_GHOST_SEARCH; + case 7: + case "TUTORIAL_ID_GHOST_COMPETITION": + return TutorialType.TUTORIAL_ID_GHOST_COMPETITION; + case 8: + case "TUTORIAL_ID_HP600_CARD": + return TutorialType.TUTORIAL_ID_HP600_CARD; + case 9: + case "TUTORIAL_ID_UNUSED_9": + return TutorialType.TUTORIAL_ID_UNUSED_9; + case 10: + case "TUTORIAL_ID_COMPETITION_QUALIFIED": + return TutorialType.TUTORIAL_ID_COMPETITION_QUALIFIED; + case 11: + case "TUTORIAL_ID_COMPETITION_TERMINAL": + return TutorialType.TUTORIAL_ID_COMPETITION_TERMINAL; + case 12: + case "TUTORIAL_ID_COMPETITION_NOTICE": + return TutorialType.TUTORIAL_ID_COMPETITION_NOTICE; + case 13: + case "TUTORIAL_ID_COMPETITION_FINISHED": + return TutorialType.TUTORIAL_ID_COMPETITION_FINISHED; + case 14: + case "TUTORIAL_ID_UNUSED_14": + return TutorialType.TUTORIAL_ID_UNUSED_14; + case 15: + case "TUTORIAL_ID_UNUSED_15": + return TutorialType.TUTORIAL_ID_UNUSED_15; + case 16: + case "TUTORIAL_ID_UNUSED_16": + return TutorialType.TUTORIAL_ID_UNUSED_16; + case 17: + case "TUTORIAL_ID_UNUSED_17": + return TutorialType.TUTORIAL_ID_UNUSED_17; + case 18: + case "TUTORIAL_ID_UNUSED_18": + return TutorialType.TUTORIAL_ID_UNUSED_18; + case 19: + case "TUTORIAL_ID_UNUSED_19": + return TutorialType.TUTORIAL_ID_UNUSED_19; + case 20: + case "TUTORIAL_ID_GHOST_STAMP": + return TutorialType.TUTORIAL_ID_GHOST_STAMP; + case 21: + case "TUTORIAL_ID_GHOST_STAMP_DECLINED": + return TutorialType.TUTORIAL_ID_GHOST_STAMP_DECLINED; + case 22: + case "TUTORIAL_ID_GHOST_STAMP_FRIENDS": + return TutorialType.TUTORIAL_ID_GHOST_STAMP_FRIENDS; + case 23: + case "TUTORIAL_ID_TERMINAL_SCRATCH": + return TutorialType.TUTORIAL_ID_TERMINAL_SCRATCH; + case 24: + case "TUTORIAL_ID_TURN_SCRATCH_SHEET": + return TutorialType.TUTORIAL_ID_TURN_SCRATCH_SHEET; + case 25: + case "TUTORIAL_ID_INVITE_FRIEND_CAMPAIGN": + return TutorialType.TUTORIAL_ID_INVITE_FRIEND_CAMPAIGN; + case 26: + case "TUTORIAL_ID_CAR_COUPON_FULL_TUNED_RECEIVABLE": + return TutorialType.TUTORIAL_ID_CAR_COUPON_FULL_TUNED_RECEIVABLE; + case 27: + case "TUTORIAL_ID_VS_CONTINUE_TICKET": + return TutorialType.TUTORIAL_ID_VS_CONTINUE_TICKET; + case 28: + case "TUTORIAL_ID_UNUSED_28": + return TutorialType.TUTORIAL_ID_UNUSED_28; + case 29: + case "TUTORIAL_ID_UNUSED_29": + return TutorialType.TUTORIAL_ID_UNUSED_29; + case 30: + case "TUTORIAL_ID_UNUSED_30": + return TutorialType.TUTORIAL_ID_UNUSED_30; + case 31: + case "TUTORIAL_ID_DRESS_UP": + return TutorialType.TUTORIAL_ID_DRESS_UP; + case 32: + case "TUTORIAL_ID_MULTI_GHOST": + return TutorialType.TUTORIAL_ID_MULTI_GHOST; + case 33: + case "TUTORIAL_ID_STORY_NEW_FEATURE": + return TutorialType.TUTORIAL_ID_STORY_NEW_FEATURE; + case 34: + case "TUTORIAL_ID_GHOST_NEW_FEATURE": + return TutorialType.TUTORIAL_ID_GHOST_NEW_FEATURE; + case 35: + case "TUTORIAL_ID_GHOST_REGION_MAP": + return TutorialType.TUTORIAL_ID_GHOST_REGION_MAP; + case -1: + case "UNRECOGNIZED": + default: + return TutorialType.UNRECOGNIZED; + } +} + +export function tutorialTypeToJSON(object: TutorialType): string { + switch (object) { + case TutorialType.TUTORIAL_ID_STORY: + return "TUTORIAL_ID_STORY"; + case TutorialType.TUTORIAL_ID_TIME_ATTACK: + return "TUTORIAL_ID_TIME_ATTACK"; + case TutorialType.TUTORIAL_ID_GHOST: + return "TUTORIAL_ID_GHOST"; + case TutorialType.TUTORIAL_ID_GHOST_CHALLENGE: + return "TUTORIAL_ID_GHOST_CHALLENGE"; + case TutorialType.TUTORIAL_ID_GHOST_LEVEL: + return "TUTORIAL_ID_GHOST_LEVEL"; + case TutorialType.TUTORIAL_ID_UNUSED_5: + return "TUTORIAL_ID_UNUSED_5"; + case TutorialType.TUTORIAL_ID_GHOST_SEARCH: + return "TUTORIAL_ID_GHOST_SEARCH"; + case TutorialType.TUTORIAL_ID_GHOST_COMPETITION: + return "TUTORIAL_ID_GHOST_COMPETITION"; + case TutorialType.TUTORIAL_ID_HP600_CARD: + return "TUTORIAL_ID_HP600_CARD"; + case TutorialType.TUTORIAL_ID_UNUSED_9: + return "TUTORIAL_ID_UNUSED_9"; + case TutorialType.TUTORIAL_ID_COMPETITION_QUALIFIED: + return "TUTORIAL_ID_COMPETITION_QUALIFIED"; + case TutorialType.TUTORIAL_ID_COMPETITION_TERMINAL: + return "TUTORIAL_ID_COMPETITION_TERMINAL"; + case TutorialType.TUTORIAL_ID_COMPETITION_NOTICE: + return "TUTORIAL_ID_COMPETITION_NOTICE"; + case TutorialType.TUTORIAL_ID_COMPETITION_FINISHED: + return "TUTORIAL_ID_COMPETITION_FINISHED"; + case TutorialType.TUTORIAL_ID_UNUSED_14: + return "TUTORIAL_ID_UNUSED_14"; + case TutorialType.TUTORIAL_ID_UNUSED_15: + return "TUTORIAL_ID_UNUSED_15"; + case TutorialType.TUTORIAL_ID_UNUSED_16: + return "TUTORIAL_ID_UNUSED_16"; + case TutorialType.TUTORIAL_ID_UNUSED_17: + return "TUTORIAL_ID_UNUSED_17"; + case TutorialType.TUTORIAL_ID_UNUSED_18: + return "TUTORIAL_ID_UNUSED_18"; + case TutorialType.TUTORIAL_ID_UNUSED_19: + return "TUTORIAL_ID_UNUSED_19"; + case TutorialType.TUTORIAL_ID_GHOST_STAMP: + return "TUTORIAL_ID_GHOST_STAMP"; + case TutorialType.TUTORIAL_ID_GHOST_STAMP_DECLINED: + return "TUTORIAL_ID_GHOST_STAMP_DECLINED"; + case TutorialType.TUTORIAL_ID_GHOST_STAMP_FRIENDS: + return "TUTORIAL_ID_GHOST_STAMP_FRIENDS"; + case TutorialType.TUTORIAL_ID_TERMINAL_SCRATCH: + return "TUTORIAL_ID_TERMINAL_SCRATCH"; + case TutorialType.TUTORIAL_ID_TURN_SCRATCH_SHEET: + return "TUTORIAL_ID_TURN_SCRATCH_SHEET"; + case TutorialType.TUTORIAL_ID_INVITE_FRIEND_CAMPAIGN: + return "TUTORIAL_ID_INVITE_FRIEND_CAMPAIGN"; + case TutorialType.TUTORIAL_ID_CAR_COUPON_FULL_TUNED_RECEIVABLE: + return "TUTORIAL_ID_CAR_COUPON_FULL_TUNED_RECEIVABLE"; + case TutorialType.TUTORIAL_ID_VS_CONTINUE_TICKET: + return "TUTORIAL_ID_VS_CONTINUE_TICKET"; + case TutorialType.TUTORIAL_ID_UNUSED_28: + return "TUTORIAL_ID_UNUSED_28"; + case TutorialType.TUTORIAL_ID_UNUSED_29: + return "TUTORIAL_ID_UNUSED_29"; + case TutorialType.TUTORIAL_ID_UNUSED_30: + return "TUTORIAL_ID_UNUSED_30"; + case TutorialType.TUTORIAL_ID_DRESS_UP: + return "TUTORIAL_ID_DRESS_UP"; + case TutorialType.TUTORIAL_ID_MULTI_GHOST: + return "TUTORIAL_ID_MULTI_GHOST"; + case TutorialType.TUTORIAL_ID_STORY_NEW_FEATURE: + return "TUTORIAL_ID_STORY_NEW_FEATURE"; + case TutorialType.TUTORIAL_ID_GHOST_NEW_FEATURE: + return "TUTORIAL_ID_GHOST_NEW_FEATURE"; + case TutorialType.TUTORIAL_ID_GHOST_REGION_MAP: + return "TUTORIAL_ID_GHOST_REGION_MAP"; + case TutorialType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum GameMode { + MODE_STORY = 1, + MODE_TIME_ATTACK = 2, + MODE_VS_BATTLE = 3, + MODE_GHOST_BATTLE = 4, + MODE_EVENT = 5, + UNRECOGNIZED = -1, +} + +export function gameModeFromJSON(object: any): GameMode { + switch (object) { + case 1: + case "MODE_STORY": + return GameMode.MODE_STORY; + case 2: + case "MODE_TIME_ATTACK": + return GameMode.MODE_TIME_ATTACK; + case 3: + case "MODE_VS_BATTLE": + return GameMode.MODE_VS_BATTLE; + case 4: + case "MODE_GHOST_BATTLE": + return GameMode.MODE_GHOST_BATTLE; + case 5: + case "MODE_EVENT": + return GameMode.MODE_EVENT; + case -1: + case "UNRECOGNIZED": + default: + return GameMode.UNRECOGNIZED; + } +} + +export function gameModeToJSON(object: GameMode): string { + switch (object) { + case GameMode.MODE_STORY: + return "MODE_STORY"; + case GameMode.MODE_TIME_ATTACK: + return "MODE_TIME_ATTACK"; + case GameMode.MODE_VS_BATTLE: + return "MODE_VS_BATTLE"; + case GameMode.MODE_GHOST_BATTLE: + return "MODE_GHOST_BATTLE"; + case GameMode.MODE_EVENT: + return "MODE_EVENT"; + case GameMode.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum GhostType { + GHOST_NORMAL = 1, + GHOST_PINCH_RUNNER = 2, + GHOST_DEFAULT = 3, + UNRECOGNIZED = -1, +} + +export function ghostTypeFromJSON(object: any): GhostType { + switch (object) { + case 1: + case "GHOST_NORMAL": + return GhostType.GHOST_NORMAL; + case 2: + case "GHOST_PINCH_RUNNER": + return GhostType.GHOST_PINCH_RUNNER; + case 3: + case "GHOST_DEFAULT": + return GhostType.GHOST_DEFAULT; + case -1: + case "UNRECOGNIZED": + default: + return GhostType.UNRECOGNIZED; + } +} + +export function ghostTypeToJSON(object: GhostType): string { + switch (object) { + case GhostType.GHOST_NORMAL: + return "GHOST_NORMAL"; + case GhostType.GHOST_PINCH_RUNNER: + return "GHOST_PINCH_RUNNER"; + case GhostType.GHOST_DEFAULT: + return "GHOST_DEFAULT"; + case GhostType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum GhostSelectionMethod { + GHOST_SEARCH_BY_REGION = 1, + GHOST_SELECT_BY_LEVEL = 2, + GHOST_SELECT_CROWN_MATCH = 3, + GHOST_SELECT_STAMP_MATCH = 4, + GHOST_SELECT_FROM_HISTORY = 5, + GHOST_SEARCH_BY_SHOP = 6, + GHOST_SEARCH_BY_NAME = 7, + GHOST_ACCEPT_CHALLENGER = 8, + GHOST_APPOINTMENT = 9, + GHOST_DEFAULT_OPPONENT = 10, + GHOST_COMPETITION = 11, + GHOST_SELECT_FROM_BOOKMARKS = 12, + UNRECOGNIZED = -1, +} + +export function ghostSelectionMethodFromJSON( + object: any +): GhostSelectionMethod { + switch (object) { + case 1: + case "GHOST_SEARCH_BY_REGION": + return GhostSelectionMethod.GHOST_SEARCH_BY_REGION; + case 2: + case "GHOST_SELECT_BY_LEVEL": + return GhostSelectionMethod.GHOST_SELECT_BY_LEVEL; + case 3: + case "GHOST_SELECT_CROWN_MATCH": + return GhostSelectionMethod.GHOST_SELECT_CROWN_MATCH; + case 4: + case "GHOST_SELECT_STAMP_MATCH": + return GhostSelectionMethod.GHOST_SELECT_STAMP_MATCH; + case 5: + case "GHOST_SELECT_FROM_HISTORY": + return GhostSelectionMethod.GHOST_SELECT_FROM_HISTORY; + case 6: + case "GHOST_SEARCH_BY_SHOP": + return GhostSelectionMethod.GHOST_SEARCH_BY_SHOP; + case 7: + case "GHOST_SEARCH_BY_NAME": + return GhostSelectionMethod.GHOST_SEARCH_BY_NAME; + case 8: + case "GHOST_ACCEPT_CHALLENGER": + return GhostSelectionMethod.GHOST_ACCEPT_CHALLENGER; + case 9: + case "GHOST_APPOINTMENT": + return GhostSelectionMethod.GHOST_APPOINTMENT; + case 10: + case "GHOST_DEFAULT_OPPONENT": + return GhostSelectionMethod.GHOST_DEFAULT_OPPONENT; + case 11: + case "GHOST_COMPETITION": + return GhostSelectionMethod.GHOST_COMPETITION; + case 12: + case "GHOST_SELECT_FROM_BOOKMARKS": + return GhostSelectionMethod.GHOST_SELECT_FROM_BOOKMARKS; + case -1: + case "UNRECOGNIZED": + default: + return GhostSelectionMethod.UNRECOGNIZED; + } +} + +export function ghostSelectionMethodToJSON( + object: GhostSelectionMethod +): string { + switch (object) { + case GhostSelectionMethod.GHOST_SEARCH_BY_REGION: + return "GHOST_SEARCH_BY_REGION"; + case GhostSelectionMethod.GHOST_SELECT_BY_LEVEL: + return "GHOST_SELECT_BY_LEVEL"; + case GhostSelectionMethod.GHOST_SELECT_CROWN_MATCH: + return "GHOST_SELECT_CROWN_MATCH"; + case GhostSelectionMethod.GHOST_SELECT_STAMP_MATCH: + return "GHOST_SELECT_STAMP_MATCH"; + case GhostSelectionMethod.GHOST_SELECT_FROM_HISTORY: + return "GHOST_SELECT_FROM_HISTORY"; + case GhostSelectionMethod.GHOST_SEARCH_BY_SHOP: + return "GHOST_SEARCH_BY_SHOP"; + case GhostSelectionMethod.GHOST_SEARCH_BY_NAME: + return "GHOST_SEARCH_BY_NAME"; + case GhostSelectionMethod.GHOST_ACCEPT_CHALLENGER: + return "GHOST_ACCEPT_CHALLENGER"; + case GhostSelectionMethod.GHOST_APPOINTMENT: + return "GHOST_APPOINTMENT"; + case GhostSelectionMethod.GHOST_DEFAULT_OPPONENT: + return "GHOST_DEFAULT_OPPONENT"; + case GhostSelectionMethod.GHOST_COMPETITION: + return "GHOST_COMPETITION"; + case GhostSelectionMethod.GHOST_SELECT_FROM_BOOKMARKS: + return "GHOST_SELECT_FROM_BOOKMARKS"; + case GhostSelectionMethod.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum GhostRateType { + GHOST_RATE_UNKNOWN = 1, + GHOST_RATE_INVALID = 2, + GHOST_RATE_VALID = 3, + UNRECOGNIZED = -1, +} + +export function ghostRateTypeFromJSON(object: any): GhostRateType { + switch (object) { + case 1: + case "GHOST_RATE_UNKNOWN": + return GhostRateType.GHOST_RATE_UNKNOWN; + case 2: + case "GHOST_RATE_INVALID": + return GhostRateType.GHOST_RATE_INVALID; + case 3: + case "GHOST_RATE_VALID": + return GhostRateType.GHOST_RATE_VALID; + case -1: + case "UNRECOGNIZED": + default: + return GhostRateType.UNRECOGNIZED; + } +} + +export function ghostRateTypeToJSON(object: GhostRateType): string { + switch (object) { + case GhostRateType.GHOST_RATE_UNKNOWN: + return "GHOST_RATE_UNKNOWN"; + case GhostRateType.GHOST_RATE_INVALID: + return "GHOST_RATE_INVALID"; + case GhostRateType.GHOST_RATE_VALID: + return "GHOST_RATE_VALID"; + case GhostRateType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum PathSelectionMethod { + PATH_NEW = 1, + PATH_PLAIN = 2, + PATH_FRIEND = 3, + PATH_NORMAL = 4, + PATH_CHALLENGER = 5, + UNRECOGNIZED = -1, +} + +export function pathSelectionMethodFromJSON(object: any): PathSelectionMethod { + switch (object) { + case 1: + case "PATH_NEW": + return PathSelectionMethod.PATH_NEW; + case 2: + case "PATH_PLAIN": + return PathSelectionMethod.PATH_PLAIN; + case 3: + case "PATH_FRIEND": + return PathSelectionMethod.PATH_FRIEND; + case 4: + case "PATH_NORMAL": + return PathSelectionMethod.PATH_NORMAL; + case 5: + case "PATH_CHALLENGER": + return PathSelectionMethod.PATH_CHALLENGER; + case -1: + case "UNRECOGNIZED": + default: + return PathSelectionMethod.UNRECOGNIZED; + } +} + +export function pathSelectionMethodToJSON(object: PathSelectionMethod): string { + switch (object) { + case PathSelectionMethod.PATH_NEW: + return "PATH_NEW"; + case PathSelectionMethod.PATH_PLAIN: + return "PATH_PLAIN"; + case PathSelectionMethod.PATH_FRIEND: + return "PATH_FRIEND"; + case PathSelectionMethod.PATH_NORMAL: + return "PATH_NORMAL"; + case PathSelectionMethod.PATH_CHALLENGER: + return "PATH_CHALLENGER"; + case PathSelectionMethod.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum NoticeEntry { + NOTICE_UNUSED_1 = 1, + NOTICE_UNUSED_2 = 2, + NOTICE_UNUSED_3 = 3, + NOTICE_UNUSED_4 = 4, + NOTICE_UNUSED_5 = 5, + NOTICE_UNUSED_6 = 6, + NOTICE_UNUSED_7 = 7, + NOTICE_UNUSED_8 = 8, + NOTICE_UNUSED_9 = 9, + NOTICE_UNUSED_10 = 10, + NOTICE_UNUSED_11 = 11, + NOTICE_UNUSED_12 = 12, + UNRECOGNIZED = -1, +} + +export function noticeEntryFromJSON(object: any): NoticeEntry { + switch (object) { + case 1: + case "NOTICE_UNUSED_1": + return NoticeEntry.NOTICE_UNUSED_1; + case 2: + case "NOTICE_UNUSED_2": + return NoticeEntry.NOTICE_UNUSED_2; + case 3: + case "NOTICE_UNUSED_3": + return NoticeEntry.NOTICE_UNUSED_3; + case 4: + case "NOTICE_UNUSED_4": + return NoticeEntry.NOTICE_UNUSED_4; + case 5: + case "NOTICE_UNUSED_5": + return NoticeEntry.NOTICE_UNUSED_5; + case 6: + case "NOTICE_UNUSED_6": + return NoticeEntry.NOTICE_UNUSED_6; + case 7: + case "NOTICE_UNUSED_7": + return NoticeEntry.NOTICE_UNUSED_7; + case 8: + case "NOTICE_UNUSED_8": + return NoticeEntry.NOTICE_UNUSED_8; + case 9: + case "NOTICE_UNUSED_9": + return NoticeEntry.NOTICE_UNUSED_9; + case 10: + case "NOTICE_UNUSED_10": + return NoticeEntry.NOTICE_UNUSED_10; + case 11: + case "NOTICE_UNUSED_11": + return NoticeEntry.NOTICE_UNUSED_11; + case 12: + case "NOTICE_UNUSED_12": + return NoticeEntry.NOTICE_UNUSED_12; + case -1: + case "UNRECOGNIZED": + default: + return NoticeEntry.UNRECOGNIZED; + } +} + +export function noticeEntryToJSON(object: NoticeEntry): string { + switch (object) { + case NoticeEntry.NOTICE_UNUSED_1: + return "NOTICE_UNUSED_1"; + case NoticeEntry.NOTICE_UNUSED_2: + return "NOTICE_UNUSED_2"; + case NoticeEntry.NOTICE_UNUSED_3: + return "NOTICE_UNUSED_3"; + case NoticeEntry.NOTICE_UNUSED_4: + return "NOTICE_UNUSED_4"; + case NoticeEntry.NOTICE_UNUSED_5: + return "NOTICE_UNUSED_5"; + case NoticeEntry.NOTICE_UNUSED_6: + return "NOTICE_UNUSED_6"; + case NoticeEntry.NOTICE_UNUSED_7: + return "NOTICE_UNUSED_7"; + case NoticeEntry.NOTICE_UNUSED_8: + return "NOTICE_UNUSED_8"; + case NoticeEntry.NOTICE_UNUSED_9: + return "NOTICE_UNUSED_9"; + case NoticeEntry.NOTICE_UNUSED_10: + return "NOTICE_UNUSED_10"; + case NoticeEntry.NOTICE_UNUSED_11: + return "NOTICE_UNUSED_11"; + case NoticeEntry.NOTICE_UNUSED_12: + return "NOTICE_UNUSED_12"; + case NoticeEntry.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FileType { + FILE_PROMOTION_ANNOUNCEMENT = 1, + FILE_FEATURE_ANNOUNCEMENT = 4, + FILE_SPAPP_ANNOUNCEMENT = 6, + UNRECOGNIZED = -1, +} + +export function fileTypeFromJSON(object: any): FileType { + switch (object) { + case 1: + case "FILE_PROMOTION_ANNOUNCEMENT": + return FileType.FILE_PROMOTION_ANNOUNCEMENT; + case 4: + case "FILE_FEATURE_ANNOUNCEMENT": + return FileType.FILE_FEATURE_ANNOUNCEMENT; + case 6: + case "FILE_SPAPP_ANNOUNCEMENT": + return FileType.FILE_SPAPP_ANNOUNCEMENT; + case -1: + case "UNRECOGNIZED": + default: + return FileType.UNRECOGNIZED; + } +} + +export function fileTypeToJSON(object: FileType): string { + switch (object) { + case FileType.FILE_PROMOTION_ANNOUNCEMENT: + return "FILE_PROMOTION_ANNOUNCEMENT"; + case FileType.FILE_FEATURE_ANNOUNCEMENT: + return "FILE_FEATURE_ANNOUNCEMENT"; + case FileType.FILE_SPAPP_ANNOUNCEMENT: + return "FILE_SPAPP_ANNOUNCEMENT"; + case FileType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum GhostCompetitionParticipantState { + COMPETITION_NOT_PARTICIPATED = 1, + COMPETITION_QUALIFIED = 2, + COMPETITION_PARTICIPATED = 3, + COMPETITION_WON = 4, + UNRECOGNIZED = -1, +} + +export function ghostCompetitionParticipantStateFromJSON( + object: any +): GhostCompetitionParticipantState { + switch (object) { + case 1: + case "COMPETITION_NOT_PARTICIPATED": + return GhostCompetitionParticipantState.COMPETITION_NOT_PARTICIPATED; + case 2: + case "COMPETITION_QUALIFIED": + return GhostCompetitionParticipantState.COMPETITION_QUALIFIED; + case 3: + case "COMPETITION_PARTICIPATED": + return GhostCompetitionParticipantState.COMPETITION_PARTICIPATED; + case 4: + case "COMPETITION_WON": + return GhostCompetitionParticipantState.COMPETITION_WON; + case -1: + case "UNRECOGNIZED": + default: + return GhostCompetitionParticipantState.UNRECOGNIZED; + } +} + +export function ghostCompetitionParticipantStateToJSON( + object: GhostCompetitionParticipantState +): string { + switch (object) { + case GhostCompetitionParticipantState.COMPETITION_NOT_PARTICIPATED: + return "COMPETITION_NOT_PARTICIPATED"; + case GhostCompetitionParticipantState.COMPETITION_QUALIFIED: + return "COMPETITION_QUALIFIED"; + case GhostCompetitionParticipantState.COMPETITION_PARTICIPATED: + return "COMPETITION_PARTICIPATED"; + case GhostCompetitionParticipantState.COMPETITION_WON: + return "COMPETITION_WON"; + case GhostCompetitionParticipantState.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum ScreenshotType { + SS_GHOST_BATTLE = 1, + SS_VERSUS_BATTLE = 2, + SS_TERMINAL = 3, + SS_ACQUIRING_VERSUS_STAR = 4, + SS_ACQUIRING_AURA_MOTIF = 5, + SS_GHOST_REGION_MAP = 6, + SS_ACQUIRING_CROWN = 7, + SS_GHOST_COMPETITION_RESULT = 8, + SS_TIME_ATTACK_RESULT = 9, + SS_LEVEL_UP = 10, + UNRECOGNIZED = -1, +} + +export function screenshotTypeFromJSON(object: any): ScreenshotType { + switch (object) { + case 1: + case "SS_GHOST_BATTLE": + return ScreenshotType.SS_GHOST_BATTLE; + case 2: + case "SS_VERSUS_BATTLE": + return ScreenshotType.SS_VERSUS_BATTLE; + case 3: + case "SS_TERMINAL": + return ScreenshotType.SS_TERMINAL; + case 4: + case "SS_ACQUIRING_VERSUS_STAR": + return ScreenshotType.SS_ACQUIRING_VERSUS_STAR; + case 5: + case "SS_ACQUIRING_AURA_MOTIF": + return ScreenshotType.SS_ACQUIRING_AURA_MOTIF; + case 6: + case "SS_GHOST_REGION_MAP": + return ScreenshotType.SS_GHOST_REGION_MAP; + case 7: + case "SS_ACQUIRING_CROWN": + return ScreenshotType.SS_ACQUIRING_CROWN; + case 8: + case "SS_GHOST_COMPETITION_RESULT": + return ScreenshotType.SS_GHOST_COMPETITION_RESULT; + case 9: + case "SS_TIME_ATTACK_RESULT": + return ScreenshotType.SS_TIME_ATTACK_RESULT; + case 10: + case "SS_LEVEL_UP": + return ScreenshotType.SS_LEVEL_UP; + case -1: + case "UNRECOGNIZED": + default: + return ScreenshotType.UNRECOGNIZED; + } +} + +export function screenshotTypeToJSON(object: ScreenshotType): string { + switch (object) { + case ScreenshotType.SS_GHOST_BATTLE: + return "SS_GHOST_BATTLE"; + case ScreenshotType.SS_VERSUS_BATTLE: + return "SS_VERSUS_BATTLE"; + case ScreenshotType.SS_TERMINAL: + return "SS_TERMINAL"; + case ScreenshotType.SS_ACQUIRING_VERSUS_STAR: + return "SS_ACQUIRING_VERSUS_STAR"; + case ScreenshotType.SS_ACQUIRING_AURA_MOTIF: + return "SS_ACQUIRING_AURA_MOTIF"; + case ScreenshotType.SS_GHOST_REGION_MAP: + return "SS_GHOST_REGION_MAP"; + case ScreenshotType.SS_ACQUIRING_CROWN: + return "SS_ACQUIRING_CROWN"; + case ScreenshotType.SS_GHOST_COMPETITION_RESULT: + return "SS_GHOST_COMPETITION_RESULT"; + case ScreenshotType.SS_TIME_ATTACK_RESULT: + return "SS_TIME_ATTACK_RESULT"; + case ScreenshotType.SS_LEVEL_UP: + return "SS_LEVEL_UP"; + case ScreenshotType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum TransferState { + NOT_REGISTERED = 0, + NEW_REGISTRATION = 1, + TRANSFER_REQUIRED = 2, + TRANSFERRING = 3, + TRANSFERRED = 4, + UNRECOGNIZED = -1, +} + +export function transferStateFromJSON(object: any): TransferState { + switch (object) { + case 0: + case "NOT_REGISTERED": + return TransferState.NOT_REGISTERED; + case 1: + case "NEW_REGISTRATION": + return TransferState.NEW_REGISTRATION; + case 2: + case "TRANSFER_REQUIRED": + return TransferState.TRANSFER_REQUIRED; + case 3: + case "TRANSFERRING": + return TransferState.TRANSFERRING; + case 4: + case "TRANSFERRED": + return TransferState.TRANSFERRED; + case -1: + case "UNRECOGNIZED": + default: + return TransferState.UNRECOGNIZED; + } +} + +export function transferStateToJSON(object: TransferState): string { + switch (object) { + case TransferState.NOT_REGISTERED: + return "NOT_REGISTERED"; + case TransferState.NEW_REGISTRATION: + return "NEW_REGISTRATION"; + case TransferState.TRANSFER_REQUIRED: + return "TRANSFER_REQUIRED"; + case TransferState.TRANSFERRING: + return "TRANSFERRING"; + case TransferState.TRANSFERRED: + return "TRANSFERRED"; + case TransferState.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum EventModeSerialErrorCode { + SERIAL_SUCCESS = 0, + SERIAL_ATTEMPT_TO_CHANGE = 1, + SERIAL_NO_INPUT = 2, + SERIAL_INVALID = 3, + SERIAL_EXPIRED = 4, + SERIAL_OTHER_PLACE = 5, + UNRECOGNIZED = -1, +} + +export function eventModeSerialErrorCodeFromJSON( + object: any +): EventModeSerialErrorCode { + switch (object) { + case 0: + case "SERIAL_SUCCESS": + return EventModeSerialErrorCode.SERIAL_SUCCESS; + case 1: + case "SERIAL_ATTEMPT_TO_CHANGE": + return EventModeSerialErrorCode.SERIAL_ATTEMPT_TO_CHANGE; + case 2: + case "SERIAL_NO_INPUT": + return EventModeSerialErrorCode.SERIAL_NO_INPUT; + case 3: + case "SERIAL_INVALID": + return EventModeSerialErrorCode.SERIAL_INVALID; + case 4: + case "SERIAL_EXPIRED": + return EventModeSerialErrorCode.SERIAL_EXPIRED; + case 5: + case "SERIAL_OTHER_PLACE": + return EventModeSerialErrorCode.SERIAL_OTHER_PLACE; + case -1: + case "UNRECOGNIZED": + default: + return EventModeSerialErrorCode.UNRECOGNIZED; + } +} + +export function eventModeSerialErrorCodeToJSON( + object: EventModeSerialErrorCode +): string { + switch (object) { + case EventModeSerialErrorCode.SERIAL_SUCCESS: + return "SERIAL_SUCCESS"; + case EventModeSerialErrorCode.SERIAL_ATTEMPT_TO_CHANGE: + return "SERIAL_ATTEMPT_TO_CHANGE"; + case EventModeSerialErrorCode.SERIAL_NO_INPUT: + return "SERIAL_NO_INPUT"; + case EventModeSerialErrorCode.SERIAL_INVALID: + return "SERIAL_INVALID"; + case EventModeSerialErrorCode.SERIAL_EXPIRED: + return "SERIAL_EXPIRED"; + case EventModeSerialErrorCode.SERIAL_OTHER_PLACE: + return "SERIAL_OTHER_PLACE"; + case EventModeSerialErrorCode.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum ClientLogType { + LOG_LOAD_REPORT = 0, + LOG_ERROR = 1, + UNRECOGNIZED = -1, +} + +export function clientLogTypeFromJSON(object: any): ClientLogType { + switch (object) { + case 0: + case "LOG_LOAD_REPORT": + return ClientLogType.LOG_LOAD_REPORT; + case 1: + case "LOG_ERROR": + return ClientLogType.LOG_ERROR; + case -1: + case "UNRECOGNIZED": + default: + return ClientLogType.UNRECOGNIZED; + } +} + +export function clientLogTypeToJSON(object: ClientLogType): string { + switch (object) { + case ClientLogType.LOG_LOAD_REPORT: + return "LOG_LOAD_REPORT"; + case ClientLogType.LOG_ERROR: + return "LOG_ERROR"; + case ClientLogType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum SmartphoneAppState { + SPAPP_UNREGISTERED = 0, + SPAPP_KTID = 1, + SPAPP_BNID = 2, + UNRECOGNIZED = -1, +} + +export function smartphoneAppStateFromJSON(object: any): SmartphoneAppState { + switch (object) { + case 0: + case "SPAPP_UNREGISTERED": + return SmartphoneAppState.SPAPP_UNREGISTERED; + case 1: + case "SPAPP_KTID": + return SmartphoneAppState.SPAPP_KTID; + case 2: + case "SPAPP_BNID": + return SmartphoneAppState.SPAPP_BNID; + case -1: + case "UNRECOGNIZED": + default: + return SmartphoneAppState.UNRECOGNIZED; + } +} + +export function smartphoneAppStateToJSON(object: SmartphoneAppState): string { + switch (object) { + case SmartphoneAppState.SPAPP_UNREGISTERED: + return "SPAPP_UNREGISTERED"; + case SmartphoneAppState.SPAPP_KTID: + return "SPAPP_KTID"; + case SmartphoneAppState.SPAPP_BNID: + return "SPAPP_BNID"; + case SmartphoneAppState.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface RegisterSystemInfoRequest { + pcbSerial: string; + terminalType: TerminalType; + romVersion: number; + country: string; + lineType: LineType; + shopName: string; + shopNickname: string; + allnetPlaceId: number; + allnetRegion0: number; + muchaPlaceId: string; + muchaPrefectureId: number; + regionName0: string; + regionName1: string; + regionName2: string; + regionName3: string; + timezoneOffset: number; + systemSetting: SystemSetting | undefined; + errorLogs: RegisterSystemInfoRequest_ErrorLogEntry[]; +} + +export interface RegisterSystemInfoRequest_ErrorLogEntry { + datetime: number; + message: string; +} + +export interface RegisterSystemInfoResponse { + error: ErrorCode; + regionId: number; + placeId: string; + allowedClientLogTypes: ClientLogType[]; + featureVersion: GameFeatureVersion | undefined; + latestCompetitionId: number; + competitionSchedule: GhostCompetitionSchedule | undefined; + scratchNotes: string; + inviteFriendCampaignSchedule: InviteFriendCampaignSchedule | undefined; + ghostSelectionMinRedoWait: number; + ghostSelectionMaxRedoWait: number; +} + +export interface RegisterSystemStatsRequest { + pcbSerial: string; + driveStats: RegisterSystemStatsRequest_DriveStats | undefined; + terminalStats: RegisterSystemStatsRequest_TerminalStats | undefined; +} + +export interface RegisterSystemStatsRequest_DriveStats { + operation: number[]; + story: number[]; + versus: number[]; + ghost: number[]; + timeAttack: number[]; + event: number[]; +} + +export interface RegisterSystemStatsRequest_TerminalStats { + operation: number[]; +} + +export interface RegisterSystemStatsResponse { + error: ErrorCode; +} + +export interface RegisterGhostTrailRequest { + ghostSessionId: number; + ghost: GhostCar | undefined; + trail: Buffer; + time: number; + driveData: BinaryData | undefined; + trendBinaryByArea: BinaryData | undefined; + trendBinaryByCar: BinaryData | undefined; + trendBinaryByUser: BinaryData | undefined; +} + +export interface RegisterGhostTrailResponse { + error: ErrorCode; +} + +export interface LoadUserRequest { + cardChipId: string; + accessCode: string; + cardTypeCode: number; + cardRegionCode: number; + device: DeviceType; + userId: number; + romVersion: number; + maxCars: number; + createUser: boolean; +} + +export interface LoadUserResponse { + error: ErrorCode; + unlockAt: number; + accessCode: string; + banapassportAmId: number; + mbid: number; + userId: number; + numOfOwnedCars: number; + cars: Car[]; + carStates: LoadUserResponse_CarState[]; + unusedCarTickets: UserItem[]; + tutorials: boolean[]; + competitionUserState: GhostCompetitionParticipantState; + windowStickerString: string; + windowStickerFont: number; + spappState: SmartphoneAppState; + transferState: TransferState; + totalVsStarCount: number; + totalVsMedalPoint: number; + copiedCar: CopiedCar | undefined; + wasCreatedToday: boolean; + participatedInInviteFriendCampaign: boolean; +} + +export interface LoadUserResponse_CarState { + hasOpponentGhost: boolean; + competitionState: GhostCompetitionParticipantState; + toBeDeleted: boolean; + eventJoined: boolean; + transferred: boolean; + driveLastPlayedAt: number; +} + +export interface UpdateUserSessionRequest { + userId: number; + cardChipId: string; + accessCode: string; + cardTypeCode: number; + cardRegionCode: number; + device: DeviceType; + unlockAt: number; + acceptVs: boolean; +} + +export interface UpdateUserSessionResponse { + error: ErrorCode; +} + +export interface LoadDriveInformationRequest { + userId: number; +} + +export interface LoadDriveInformationResponse { + error: ErrorCode; + noticeWindow: NoticeEntry[]; + noticeWindowMessage: string[]; + transferNotice: TransferNotice | undefined; + restrictedModels: number[]; + announceFeature: boolean; + announceMobile: boolean; + availableTickets: UserItem[]; +} + +export interface LoadCarRequest { + carId: number; + eventMode: boolean; + eventModeSerial: string; +} + +export interface LoadCarResponse { + error: ErrorCode; + car: Car | undefined; + tuningPoint: number; + odometer: number; + playCount: number; + earnedCustomColor: boolean; + setting: CarSetting | undefined; + vsPlayCount: number; + vsBurstCount: number; + vsStarCount: number; + vsStarCountMax: number; + vsCoolOrWild: number; + vsSmoothOrRough: number; + vsTripleStarMedals: number; + vsDoubleStarMedals: number; + vsSingleStarMedals: number; + vsPlainMedals: number; + rgPlayCount: number; + rgWinCount: number; + rgTrophy: number; + rgPreviousVersionPlayCount: number; + rgScore: number; + rgRegionMapScore: number[]; + rgRegions: number[]; + rgStamp: number; + rgAcquireAllCrowns: boolean; + dressupLevel: number; + dressupPoint: number; + stPlayCount: number; + stClearBits: number; + stClearDivCount: number; + stClearCount: number; + stLoseBits: number; + stConsecutiveWins: number; + stConsecutiveWinsMax: number; + stCompleted100Episodes: boolean; + challenger: ChallengerCar | undefined; + challengerReturnCount: number; + numOfChallengers: number; + opponentGhost: GhostCar | undefined; + opponentTrailId: number; + opponentCompetitionId: number; + competitionParameter: GhostCompetitionParameter | undefined; + specialTitles: string[]; + earnedTitles: string[]; + ownedItems: CarItem[]; + auraMotifAutoChange: boolean; + screenshotCount: number; + announceEventModePrize: boolean; + transferred: boolean; + driveLastPlayedAt: number; + insurance: LoadCarResponse_StoryInsurance | undefined; +} + +export interface LoadCarResponse_StoryInsurance { + numOfRemains: number; +} + +export interface CreateCarRequest { + userId: number; + banapassportAmId: number; + cardChipId: string; + accessCode: string; + cardTypeCode: number; + cardRegionCode: number; + device: DeviceType; + car: Car | undefined; + transmission: boolean; + timestamp: number; + userItemId: number; + deletedCarId: number; +} + +export interface CreateCarResponse { + error: ErrorCode; + accessCode: string; + banapassportAmId: number; + mbid: number; + userId: number; + carId: number; + stClearBits: number; + stClearDivCount: number; + stClearCount: number; + stLoseBits: number; + stConsecutiveWins: number; + stConsecutiveWinsMax: number; + fullTunedCarCouponUnreceivableAt: number; +} + +export interface LoadGameHistoryRequest { + carId: number; +} + +export interface LoadGameHistoryResponse { + error: ErrorCode; + taRecords: LoadGameHistoryResponse_TimeAttackRecord[]; + taRankingUpdatedAt: number; + ghostHistory: LoadGameHistoryResponse_GhostBattleRecord[]; + ghostBattleCount: number; + ghostBattleWinCount: number; + stampSheetCount: number; + stampSheet: number[]; +} + +export interface LoadGameHistoryResponse_TimeAttackRecord { + course: number; + time: number; + tunePower: number; + tuneHandling: number; + wholeRank: number; + wholeParticipants: number; + modelRank: number; + modelParticipants: number; +} + +export interface LoadGameHistoryResponse_GhostBattleRecord { + carSetting: + | LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting + | undefined; + opponent: + | LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar + | undefined; + mobs: LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar[]; + area: number; + playedAt: number; + playedShopName: string; +} + +export interface LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting { + tunePower: number; + tuneHandling: number; +} + +export interface LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar { + car: Car | undefined; + result: number; +} + +export interface UpdateCarRequest { + carId: number; + car: Car | undefined; + earnedItems: CarItem[]; + setting: CarSetting | undefined; + toBeDeleted: boolean; + auraMotifAutoChange: boolean; + rgStamp: number; + timestamp: number; +} + +export interface UpdateCarResponse { + error: ErrorCode; +} + +export interface SaveGameResultRequest { + carId: number; + gameMode: GameMode; + playedAt: number; + playCount: number; + retired: boolean; + timeup: boolean; + car: Car | undefined; + setting: CarSetting | undefined; + odometer: number; + earnedCustomColor: boolean; + confirmedTutorials: TutorialType[]; + earnedItems: CarItem[]; + earnedUserItems: UserItem[]; + preservedTitles: string[]; + neighborCars: number[]; + stResult: SaveGameResultRequest_StoryResult | undefined; + taResult: SaveGameResultRequest_TimeAttackResult | undefined; + vsResult: SaveGameResultRequest_VersusBattleResult | undefined; + rgResult: SaveGameResultRequest_GhostBattleResult | undefined; +} + +export interface SaveGameResultRequest_StoryResult { + stPlayCount: number; + stPlayedStory: number; + tuningPoint: number; + stClearBits: number; + stClearDivCount: number; + stClearCount: number; + stLoseBits: number; + stConsecutiveWins: number; + stCompleted100Episodes: boolean; + isInsuranceUsed: boolean; +} + +export interface SaveGameResultRequest_TimeAttackResult { + time: number; + course: number; + isMorning: boolean; + section1Time: number; + section2Time: number; + section3Time: number; + section4Time: number; + section5Time: number; + section6Time: number; + section7Time: number; + wholeRank: number; + modelRank: number; +} + +export interface SaveGameResultRequest_VersusBattleResult { + result: number; + survived: boolean; + opponentCarId: number[]; + numOfPlayers: number; + area: number; + isMorning: boolean; + vsPlayCount: number; + vsBurstCount: number; + vsStarCount: number; + vsCoolOrWild: number; + vsSmoothOrRough: number; + vsTripleStarMedals: number; + vsDoubleStarMedals: number; + vsSingleStarMedals: number; + vsPlainMedals: number; +} + +export interface SaveGameResultRequest_GhostBattleResult { + opponents: SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent[]; + path: number; + isMorning: boolean; + selectionMethod: GhostSelectionMethod; + stampSheetCount: number; + stampSheet: number[]; + rgStamp: number; + confirmedTransferredStampTargetCarIds: number[]; + rgPlayCount: number; + dressupLevel: number; + dressupPoint: number; + rgRegionMapScore: number[]; + competitionId: number; + periodId: number; + brakingPoint: number; + acquireCrown: boolean; + acquireAllCrowns: boolean; +} + +export interface SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent { + result: number; + carId: number; + tunePower: number; + tuneHandling: number; + receiveStamp: boolean; +} + +export interface SaveGameResultResponse { + error: ErrorCode; + ghostSessionId: number; + availableTickets: UserItem[]; +} + +export interface SaveChargeRequest { + chargeLogs: SaveChargeRequest_ChargeLog[]; +} + +export interface SaveChargeRequest_ChargeLog { + datetime: number; + pcbSerial: string; + placeId: string; + userId: number; +} + +export interface SaveChargeResponse { + error: ErrorCode; +} + +export interface LoadGhostBattleInfoRequest { + carId: number; +} + +export interface LoadGhostBattleInfoResponse { + error: ErrorCode; + friendCars: FriendCar[]; + challengers: ChallengerCar[]; + stampTargetCars: StampTargetCar[]; + previousVersionStampTargetCars: PreviousVersionStampTargetCar[]; + bookmarkedCars: BookmarkedCar[]; + history: Car[]; + weakenedCars: LoadGhostBattleInfoResponse_WeakenedCar[]; + stampSheetCount: number; + stampSheet: number[]; + stampReturnStats: number[]; +} + +export interface LoadGhostBattleInfoResponse_WeakenedCar { + carId: number; + consecutiveLosses: number; +} + +export interface LoadStampTargetRequest { + carId: number; + needToPromote: boolean; +} + +export interface LoadStampTargetResponse { + error: ErrorCode; + cars: StampTargetCar[]; + challengers: ChallengerCar[]; +} + +export interface LockStampTargetRequest { + carId: number; + targetCars: number[]; +} + +export interface LockStampTargetResponse { + error: ErrorCode; +} + +export interface LoadGhostCompetitionInfoRequest { + carId: number; + competitionId: number; +} + +export interface LoadGhostCompetitionInfoResponse { + error: ErrorCode; + periodId: number; + closed: boolean; + brakingPoint: number; + qualified: boolean; + topResults: number[]; + result: number; + rank: number; + parameters1: number[]; + parameters2: boolean; +} + +export interface LoadTimeAttackRecordRequest { + carId: number; + model: number; + course: number; +} + +export interface LoadTimeAttackRecordResponse { + error: ErrorCode; + wholeRanking: number[]; + modelRanking: number[]; + personalBestTime: number; + pbSection1Time: number; + pbSection2Time: number; + pbSection3Time: number; + pbSection4Time: number; + pbSection5Time: number; + pbSection6Time: number; + pbSection7Time: number; +} + +export interface SaveTerminalResultRequest { + userId: number; + timestamp: number; + carOrder: number[]; + confirmedTutorials: TutorialType[]; + garageMenuEntered: boolean; +} + +export interface SaveTerminalResultResponse { + error: ErrorCode; +} + +export interface PingRequest { + ping: number; +} + +export interface PingResponse { + error: ErrorCode; + pong: number; +} + +export interface LoadTerminalInformationRequest { + userId: number; +} + +export interface LoadTerminalInformationResponse { + error: ErrorCode; + prizeReceivable: boolean; + noticeEntries: LoadTerminalInformationResponse_TerminalNotice[]; + noticeMessage: string[]; + noticeWindow: NoticeEntry[]; + noticeWindowMessage: string[]; + transferNotice: TransferNotice | undefined; + announceFeature: boolean; + freeScratched: boolean; + restrictedModels: number[]; +} + +export interface LoadTerminalInformationResponse_TerminalNotice { + noticeType: NoticeEntry; + field1: string; + field2: number; + field3: number; +} + +export interface CreateUserRequest { + banapassportAmId: number; + cardChipId: string; + accessCode: string; + cardTypeCode: number; + cardRegionCode: number; + device: DeviceType; + timestamp: number; +} + +export interface CreateUserResponse { + error: ErrorCode; + accessCode: string; + banapassportAmId: number; + mbid: number; + userId: number; +} + +export interface AskAccessCodeRequest { + cardChipId: string; +} + +export interface AskAccessCodeResponse { + error: ErrorCode; + accessCode: string; +} + +export interface RegisterOpponentGhostRequest { + carId: number; + specialGhostId: number; +} + +export interface RegisterOpponentGhostResponse { + error: ErrorCode; +} + +export interface GrantCarRightRequest { + userId: number; + targetUserId: number; + timestamp: number; +} + +export interface GrantCarRightResponse { + error: ErrorCode; +} + +export interface LoadGhostCompetitionRankingRequest { + carId: number; + competitionId: number; +} + +export interface LoadGhostCompetitionRankingResponse { + error: ErrorCode; + periodId: number; + numOfParticipants: number; + competitionSchedule: GhostCompetitionSchedule | undefined; + ownRecord: LoadGhostCompetitionRankingResponse_Entry | undefined; + topRecords: LoadGhostCompetitionRankingResponse_Entry[]; +} + +export interface LoadGhostCompetitionRankingResponse_Entry { + rank: number; + result: number; + carId: number; + name: string; + regionId: number; + model: number; + visualModel: number; + defaultColor: number; + title: string; + level: number; + windowStickerString: string; + playedShopName: string; + playedAt: number; +} + +export interface LoadUnreceivedUserItemsRequest { + userId: number; +} + +export interface LoadUnreceivedUserItemsResponse { + error: ErrorCode; + ownedUserItems: UserItem[]; +} + +export interface LoadBookmarksRequest { + userId: number; +} + +export interface LoadBookmarksResponse { + error: ErrorCode; + cars: Car[]; +} + +export interface SaveBookmarksRequest { + userId: number; + cars: number[]; +} + +export interface SaveBookmarksResponse { + error: ErrorCode; +} + +export interface StartTransferRequest { + banapassportAmId: number; +} + +export interface StartTransferResponse { + error: ErrorCode; + userId: number; + pollingInterval: number; +} + +export interface SaveScreenshotRequest { + carId: number; + timestamp: number; + playedAt: number; + transparent: boolean; + imageType: ScreenshotType; + image: Buffer; + ghostMetadata: SaveScreenshotRequest_GhostBattleMetadata | undefined; + versusMetadata: SaveScreenshotRequest_VersusBattleMetadata | undefined; + terminalMetadata: SaveScreenshotRequest_TerminalMetadata | undefined; + acquiringVsStarMetadata: + | SaveScreenshotRequest_AcquiringVersusStarMetadata + | undefined; + acquiringAuraMotifMetadata: + | SaveScreenshotRequest_AcquiringAuraMotifMetadata + | undefined; + ghostRegionMapMetadata: + | SaveScreenshotRequest_GhostRegionMapMetadata + | undefined; + acquiringCrownMetadata: + | SaveScreenshotRequest_AcquiringCrownMetadata + | undefined; + competitionResultMetadata: + | SaveScreenshotRequest_GhostCompetitionResultMetadata + | undefined; + timeAttackResultMetadata: + | SaveScreenshotRequest_TimeAttackResultMetadata + | undefined; + levelUpMetadata: SaveScreenshotRequest_LevelUpMetadata | undefined; +} + +export interface SaveScreenshotRequest_GhostBattleMetadata { + tunePower: number; + tuneHandling: number; + area: number; + stampReturnCount: number; + opponents: SaveScreenshotRequest_OpponentCar[]; +} + +export interface SaveScreenshotRequest_VersusBattleMetadata { + tunePower: number; + tuneHandling: number; + area: number; + opponents: SaveScreenshotRequest_OpponentCar[]; +} + +export interface SaveScreenshotRequest_TerminalMetadata { + tunePower: number; + tuneHandling: number; + name: string; + title: string; + level: number; +} + +export interface SaveScreenshotRequest_AcquiringVersusStarMetadata { + tunePower: number; + tuneHandling: number; + vsStarCount: number; +} + +export interface SaveScreenshotRequest_AcquiringAuraMotifMetadata { + tunePower: number; + tuneHandling: number; + auraMotif: number; +} + +export interface SaveScreenshotRequest_GhostRegionMapMetadata { + tunePower: number; + tuneHandling: number; + rgScore: number; + rgRegionMapScore: number[]; +} + +export interface SaveScreenshotRequest_AcquiringCrownMetadata { + tunePower: number; + tuneHandling: number; + area: number; +} + +export interface SaveScreenshotRequest_GhostCompetitionResultMetadata { + tunePower: number; + tuneHandling: number; + rank: number; + result: number; +} + +export interface SaveScreenshotRequest_TimeAttackResultMetadata { + tunePower: number; + tuneHandling: number; + course: number; + wholeRank: number; + modelRank: number; +} + +export interface SaveScreenshotRequest_LevelUpMetadata { + tunePower: number; + tuneHandling: number; + level: number; +} + +export interface SaveScreenshotRequest_OpponentCar { + carId: number; + tunePower: number; + tuneHandling: number; +} + +export interface SaveScreenshotResponse { + error: ErrorCode; +} + +export interface SubmitClientLogRequest { + data: Buffer; + modifiedAt: number; + logType: ClientLogType; +} + +export interface SubmitClientLogResponse { + error: ErrorCode; +} + +export interface LoadScratchInformationRequest { + userId: number; +} + +export interface LoadScratchInformationResponse { + error: ErrorCode; + scratchSheets: ScratchSheet[]; + currentSheet: number; + numOfScratched: number; + ownedUserItems: UserItem[]; +} + +export interface SaveScratchSheetRequest { + timestamp: number; + targetSheet: number; + targetSquare: number; + userId: number; +} + +export interface SaveScratchSheetResponse { + error: ErrorCode; + scratchSheets: ScratchSheet[]; + currentSheet: number; + numOfScratched: number; + earnedItem: UserItem | undefined; +} + +export interface TurnScratchSheetRequest { + userId: number; + targetSheet: number; +} + +export interface TurnScratchSheetResponse { + error: ErrorCode; +} + +export interface CheckItemReceivableCarsRequest { + userId: number; + itemsToBeEarned: UserItem[]; +} + +export interface CheckItemReceivableCarsResponse { + error: ErrorCode; + carIds: number[]; +} + +export interface ReceiveUserItemsRequest { + carId: number; + targetItemIds: number[]; +} + +export interface ReceiveUserItemsResponse { + error: ErrorCode; +} + +export interface UpdateEventModeSerialRequest { + eventModeSerial: string; +} + +export interface UpdateEventModeSerialResponse { + error: ErrorCode; + serialError: EventModeSerialErrorCode; + eventModeSerial: string; + startAt: number; + endAt: number; +} + +export interface ParticipateInInviteFriendCampaignRequest { + invitingUserId: number; + invitedUserId: number; + sourceCarId: number; + transmission: boolean; +} + +export interface ParticipateInInviteFriendCampaignResponse { + error: ErrorCode; +} + +export interface ConsumeUserItemRequest { + userId: number; + carId: number; + userItemId: number; +} + +export interface ConsumeUserItemResponse { + error: ErrorCode; +} + +export interface SearchCarsByLevelRequest { + carId: number; + ghostLevel: number; + area: number; + regionId: number; +} + +export interface SearchCarsByLevelResponse { + error: ErrorCode; + ramp: number; + path: number; + ghosts: GhostCar[]; + selectionMethod: PathSelectionMethod; + rates: SearchCarsByLevelResponse_Rate[]; +} + +export interface SearchCarsByLevelResponse_Rate { + carId: number; + type: GhostRateType; + rate: number; +} + +export interface LoadPathsAndTuningsRequest { + carId: number; + selectedCars: number[]; + returnImmediately: boolean; + stampTargetArea: number; +} + +export interface LoadPathsAndTuningsResponse { + error: ErrorCode; + data: LoadPathsAndTuningsResponse_CarTuningsByPath[]; +} + +export interface LoadPathsAndTuningsResponse_CarTuningsByPath { + area: number; + ramp: number; + path: number; + carTunings: CarTuning[]; + selectionMethod: PathSelectionMethod; +} + +export interface LoadGhostDriveDataRequest { + path: number; + carTunings: CarTuning[]; +} + +export interface LoadGhostDriveDataResponse { + error: ErrorCode; + data: LoadGhostDriveDataResponse_GhostDriveData[]; +} + +export interface LoadGhostDriveDataResponse_GhostDriveData { + carId: number; + type: GhostType; + driveData: BinaryData | undefined; + trendBinaryByUser: BinaryData | undefined; + trendBinaryByCar: BinaryData | undefined; + trendBinaryByArea: BinaryData | undefined; +} + +export interface Car { + carId: number; + userId: number; + regionId: number; + name: string; + manufacturer: number; + model: number; + visualModel: number; + defaultColor: number; + customColor: number; + wheel: number; + wheelColor: number; + aero: number; + bonnet: number; + wing: number; + gtWing: GTWing | undefined; + mirror: number; + neon: number; + trunk: number; + plate: number; + plateColor: number; + plateNumber: number; + tunePower: number; + tuneHandling: number; + title: string; + level: number; + windowSticker: boolean; + windowStickerString: string; + windowStickerFont: number; + windowDecoration: number; + rivalMarker: number; + lastPlayedAt: number; + lastPlayedPlace: Place | undefined; + aura: number; + auraMotif: number; + ghostLevel: number; + country: string; + searchCode: string; +} + +export interface CarSetting { + carId: number; + view: boolean; + transmission: boolean; + retire: boolean; + meter: number; + navigationMap: boolean; + volume: number; + bgm: number; + nameplate: number; + nameplateColor: number; + terminalBackground: number; +} + +export interface GTWing { + pillar: number; + pillarMaterial: number; + mainWing: number; + mainWingColor: number; + wingTip: number; + material: number; +} + +export interface CarItem { + category: ItemCategory; + itemId: number; + amount: number; +} + +export interface CopiedCar { + car: Car | undefined; + remainingPlayCounts: number; +} + +export interface FriendCar { + car: Car | undefined; + friendshipLevel: number; + nonhuman: boolean; +} + +export interface ChallengerCar { + car: Car | undefined; + stamp: number; + result: number; + area: number; +} + +export interface StampTargetCar { + car: Car | undefined; + returnCount: number; + locked: boolean; + recommended: boolean; +} + +export interface BookmarkedCar { + car: Car | undefined; + returnCount: number; +} + +export interface PreviousVersionStampTargetCar { + car: Car | undefined; + returnCount: number; + currentCarId: number; +} + +export interface GhostCar { + car: Car | undefined; + area: number; + ramp: number; + path: number; + nonhuman: boolean; + type: GhostType; + trailId: number; +} + +export interface Place { + placeId: string; + shopName: string; + regionId: number; + country: string; +} + +export interface SystemSetting { + mCoinChute: number; + mBuyCardCost: number; + mGameCost: number; + mContinueCost: number; + mFullCourseCost: number; + mFreePlay: boolean; + mPcbId: number; + mIcCardRw: boolean; + mIcCardVender: boolean; + mMgCardRw: boolean; + mForceFeedback: boolean; + mWinsAndRemains: boolean; + mEventMode: number; + mEventModeDist: boolean; + mCloseType: number; + mCloseSun: number; + mCloseMon: number; + mCloseTue: number; + mCloseWed: number; + mCloseThu: number; + mCloseFri: number; + mCloseSat: number; + mCloseDay: number; + mTouchPanel: boolean; + mGameVol: number; + mAttractVol: number; + mCalibHandleCenter: number; + mCalibAccelCenter: number; + mCalibBrakeCenter: number; + mCalibTouchLeft: number; + mCalibTouchRight: number; + mCalibTouchTop: number; + mCalibTouchBottom: number; +} + +export interface GhostCompetitionSchedule { + competitionId: number; + qualifyingPeriodStartAt: number; + qualifyingPeriodCloseAt: number; + competitionStartAt: number; + competitionCloseAt: number; + competitionEndAt: number; + lengthOfPeriod: number; + lengthOfInterval: number; + area: number; + minigamePatternId: number; +} + +export interface GhostCompetitionParameter { + parameters1: number[]; + parameters2: boolean; +} + +export interface TransferNotice { + needToSeeTransferred: boolean; + totalMaxiGold: number; + numOfPorscheCars: number; + porscheModels: number[]; + hasR35: boolean; +} + +export interface GameFeatureVersion { + version: number; + year: number; + month: number; + pluses: number; + releaseAt: number; +} + +export interface ScratchSheet { + squares: ScratchSheet_ScratchSquare[]; +} + +export interface ScratchSheet_ScratchSquare { + category: ItemCategory; + itemId: number; + earned: boolean; +} + +export interface UserItem { + category: ItemCategory; + itemId: number; + userItemId: number; + earnedAt: number; + expireAt: number; +} + +export interface InviteFriendCampaignSchedule { + campaignId: number; + startAt: number; + endAt: number; + couponUnreceivableAt: number; +} + +export interface CarTuning { + carId: number; + tunePower: number; + tuneHandling: number; + lastPlayedAt: number; +} + +export interface BinaryData { + data: Buffer; + mergeSerial: number; +} + +export interface GhostTrail { + carId: number; + area: number; + ramp: number; + path: number; + playedAt: number; + playedPlace: Place | undefined; + trail: Buffer; +} + +export interface PlaceList { + places: Place[]; +} + +export interface GhostList { + ghosts: GhostCar[]; +} + +export interface CarSummary { + hitCount: number; + cars: Car[]; +} + +export interface FileList { + files: FileList_FileInfo[]; + interval: number; +} + +export interface FileList_FileInfo { + fileId: number; + fileType: FileType; + fileSize: number; + url: string; + sha1sum: Buffer; + notBefore: number; + notAfter: number; +} + +export interface GhostCompetitionTarget { + competitionId: number; + specialGhostId: number; + ghostCar: GhostCar | undefined; + trailId: number; + updatedAt: number; + competitionSchedule: GhostCompetitionSchedule | undefined; +} + +function createBaseRegisterSystemInfoRequest(): RegisterSystemInfoRequest { + return { + pcbSerial: "", + terminalType: 0, + romVersion: 0, + country: "", + lineType: 0, + shopName: "", + shopNickname: "", + allnetPlaceId: 0, + allnetRegion0: 0, + muchaPlaceId: "", + muchaPrefectureId: 0, + regionName0: "", + regionName1: "", + regionName2: "", + regionName3: "", + timezoneOffset: 0, + systemSetting: undefined, + errorLogs: [], + }; +} + +export const RegisterSystemInfoRequest = { + encode( + message: RegisterSystemInfoRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.pcbSerial !== "") { + writer.uint32(10).string(message.pcbSerial); + } + if (message.terminalType !== 0) { + writer.uint32(16).int32(message.terminalType); + } + if (message.romVersion !== 0) { + writer.uint32(24).uint32(message.romVersion); + } + if (message.country !== "") { + writer.uint32(34).string(message.country); + } + if (message.lineType !== 0) { + writer.uint32(40).int32(message.lineType); + } + if (message.shopName !== "") { + writer.uint32(50).string(message.shopName); + } + if (message.shopNickname !== "") { + writer.uint32(58).string(message.shopNickname); + } + if (message.allnetPlaceId !== 0) { + writer.uint32(64).uint32(message.allnetPlaceId); + } + if (message.allnetRegion0 !== 0) { + writer.uint32(72).uint32(message.allnetRegion0); + } + if (message.muchaPlaceId !== "") { + writer.uint32(82).string(message.muchaPlaceId); + } + if (message.muchaPrefectureId !== 0) { + writer.uint32(88).uint32(message.muchaPrefectureId); + } + if (message.regionName0 !== "") { + writer.uint32(98).string(message.regionName0); + } + if (message.regionName1 !== "") { + writer.uint32(106).string(message.regionName1); + } + if (message.regionName2 !== "") { + writer.uint32(114).string(message.regionName2); + } + if (message.regionName3 !== "") { + writer.uint32(122).string(message.regionName3); + } + if (message.timezoneOffset !== 0) { + writer.uint32(128).sint32(message.timezoneOffset); + } + if (message.systemSetting !== undefined) { + SystemSetting.encode( + message.systemSetting, + writer.uint32(138).fork() + ).ldelim(); + } + for (const v of message.errorLogs) { + RegisterSystemInfoRequest_ErrorLogEntry.encode( + v!, + writer.uint32(146).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemInfoRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemInfoRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pcbSerial = reader.string(); + break; + case 2: + message.terminalType = reader.int32() as any; + break; + case 3: + message.romVersion = reader.uint32(); + break; + case 4: + message.country = reader.string(); + break; + case 5: + message.lineType = reader.int32() as any; + break; + case 6: + message.shopName = reader.string(); + break; + case 7: + message.shopNickname = reader.string(); + break; + case 8: + message.allnetPlaceId = reader.uint32(); + break; + case 9: + message.allnetRegion0 = reader.uint32(); + break; + case 10: + message.muchaPlaceId = reader.string(); + break; + case 11: + message.muchaPrefectureId = reader.uint32(); + break; + case 12: + message.regionName0 = reader.string(); + break; + case 13: + message.regionName1 = reader.string(); + break; + case 14: + message.regionName2 = reader.string(); + break; + case 15: + message.regionName3 = reader.string(); + break; + case 16: + message.timezoneOffset = reader.sint32(); + break; + case 17: + message.systemSetting = SystemSetting.decode(reader, reader.uint32()); + break; + case 18: + message.errorLogs.push( + RegisterSystemInfoRequest_ErrorLogEntry.decode( + reader, + reader.uint32() + ) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemInfoRequest { + return { + pcbSerial: isSet(object.pcbSerial) ? String(object.pcbSerial) : "", + terminalType: isSet(object.terminalType) + ? terminalTypeFromJSON(object.terminalType) + : 0, + romVersion: isSet(object.romVersion) ? Number(object.romVersion) : 0, + country: isSet(object.country) ? String(object.country) : "", + lineType: isSet(object.lineType) ? lineTypeFromJSON(object.lineType) : 0, + shopName: isSet(object.shopName) ? String(object.shopName) : "", + shopNickname: isSet(object.shopNickname) + ? String(object.shopNickname) + : "", + allnetPlaceId: isSet(object.allnetPlaceId) + ? Number(object.allnetPlaceId) + : 0, + allnetRegion0: isSet(object.allnetRegion0) + ? Number(object.allnetRegion0) + : 0, + muchaPlaceId: isSet(object.muchaPlaceId) + ? String(object.muchaPlaceId) + : "", + muchaPrefectureId: isSet(object.muchaPrefectureId) + ? Number(object.muchaPrefectureId) + : 0, + regionName0: isSet(object.regionName0) ? String(object.regionName0) : "", + regionName1: isSet(object.regionName1) ? String(object.regionName1) : "", + regionName2: isSet(object.regionName2) ? String(object.regionName2) : "", + regionName3: isSet(object.regionName3) ? String(object.regionName3) : "", + timezoneOffset: isSet(object.timezoneOffset) + ? Number(object.timezoneOffset) + : 0, + systemSetting: isSet(object.systemSetting) + ? SystemSetting.fromJSON(object.systemSetting) + : undefined, + errorLogs: Array.isArray(object?.errorLogs) + ? object.errorLogs.map((e: any) => + RegisterSystemInfoRequest_ErrorLogEntry.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: RegisterSystemInfoRequest): unknown { + const obj: any = {}; + message.pcbSerial !== undefined && (obj.pcbSerial = message.pcbSerial); + message.terminalType !== undefined && + (obj.terminalType = terminalTypeToJSON(message.terminalType)); + message.romVersion !== undefined && + (obj.romVersion = Math.round(message.romVersion)); + message.country !== undefined && (obj.country = message.country); + message.lineType !== undefined && + (obj.lineType = lineTypeToJSON(message.lineType)); + message.shopName !== undefined && (obj.shopName = message.shopName); + message.shopNickname !== undefined && + (obj.shopNickname = message.shopNickname); + message.allnetPlaceId !== undefined && + (obj.allnetPlaceId = Math.round(message.allnetPlaceId)); + message.allnetRegion0 !== undefined && + (obj.allnetRegion0 = Math.round(message.allnetRegion0)); + message.muchaPlaceId !== undefined && + (obj.muchaPlaceId = message.muchaPlaceId); + message.muchaPrefectureId !== undefined && + (obj.muchaPrefectureId = Math.round(message.muchaPrefectureId)); + message.regionName0 !== undefined && + (obj.regionName0 = message.regionName0); + message.regionName1 !== undefined && + (obj.regionName1 = message.regionName1); + message.regionName2 !== undefined && + (obj.regionName2 = message.regionName2); + message.regionName3 !== undefined && + (obj.regionName3 = message.regionName3); + message.timezoneOffset !== undefined && + (obj.timezoneOffset = Math.round(message.timezoneOffset)); + message.systemSetting !== undefined && + (obj.systemSetting = message.systemSetting + ? SystemSetting.toJSON(message.systemSetting) + : undefined); + if (message.errorLogs) { + obj.errorLogs = message.errorLogs.map((e) => + e ? RegisterSystemInfoRequest_ErrorLogEntry.toJSON(e) : undefined + ); + } else { + obj.errorLogs = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterSystemInfoRequest { + const message = createBaseRegisterSystemInfoRequest(); + message.pcbSerial = object.pcbSerial ?? ""; + message.terminalType = object.terminalType ?? 0; + message.romVersion = object.romVersion ?? 0; + message.country = object.country ?? ""; + message.lineType = object.lineType ?? 0; + message.shopName = object.shopName ?? ""; + message.shopNickname = object.shopNickname ?? ""; + message.allnetPlaceId = object.allnetPlaceId ?? 0; + message.allnetRegion0 = object.allnetRegion0 ?? 0; + message.muchaPlaceId = object.muchaPlaceId ?? ""; + message.muchaPrefectureId = object.muchaPrefectureId ?? 0; + message.regionName0 = object.regionName0 ?? ""; + message.regionName1 = object.regionName1 ?? ""; + message.regionName2 = object.regionName2 ?? ""; + message.regionName3 = object.regionName3 ?? ""; + message.timezoneOffset = object.timezoneOffset ?? 0; + message.systemSetting = + object.systemSetting !== undefined && object.systemSetting !== null + ? SystemSetting.fromPartial(object.systemSetting) + : undefined; + message.errorLogs = + object.errorLogs?.map((e) => + RegisterSystemInfoRequest_ErrorLogEntry.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseRegisterSystemInfoRequest_ErrorLogEntry(): RegisterSystemInfoRequest_ErrorLogEntry { + return { datetime: 0, message: "" }; +} + +export const RegisterSystemInfoRequest_ErrorLogEntry = { + encode( + message: RegisterSystemInfoRequest_ErrorLogEntry, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.datetime !== 0) { + writer.uint32(8).uint32(message.datetime); + } + if (message.message !== "") { + writer.uint32(18).string(message.message); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemInfoRequest_ErrorLogEntry { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemInfoRequest_ErrorLogEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.datetime = reader.uint32(); + break; + case 2: + message.message = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemInfoRequest_ErrorLogEntry { + return { + datetime: isSet(object.datetime) ? Number(object.datetime) : 0, + message: isSet(object.message) ? String(object.message) : "", + }; + }, + + toJSON(message: RegisterSystemInfoRequest_ErrorLogEntry): unknown { + const obj: any = {}; + message.datetime !== undefined && + (obj.datetime = Math.round(message.datetime)); + message.message !== undefined && (obj.message = message.message); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): RegisterSystemInfoRequest_ErrorLogEntry { + const message = createBaseRegisterSystemInfoRequest_ErrorLogEntry(); + message.datetime = object.datetime ?? 0; + message.message = object.message ?? ""; + return message; + }, +}; + +function createBaseRegisterSystemInfoResponse(): RegisterSystemInfoResponse { + return { + error: 0, + regionId: 0, + placeId: "", + allowedClientLogTypes: [], + featureVersion: undefined, + latestCompetitionId: 0, + competitionSchedule: undefined, + scratchNotes: "", + inviteFriendCampaignSchedule: undefined, + ghostSelectionMinRedoWait: 0, + ghostSelectionMaxRedoWait: 0, + }; +} + +export const RegisterSystemInfoResponse = { + encode( + message: RegisterSystemInfoResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.regionId !== 0) { + writer.uint32(16).uint32(message.regionId); + } + if (message.placeId !== "") { + writer.uint32(26).string(message.placeId); + } + writer.uint32(34).fork(); + for (const v of message.allowedClientLogTypes) { + writer.int32(v); + } + writer.ldelim(); + if (message.featureVersion !== undefined) { + GameFeatureVersion.encode( + message.featureVersion, + writer.uint32(82).fork() + ).ldelim(); + } + if (message.latestCompetitionId !== 0) { + writer.uint32(88).uint32(message.latestCompetitionId); + } + if (message.competitionSchedule !== undefined) { + GhostCompetitionSchedule.encode( + message.competitionSchedule, + writer.uint32(98).fork() + ).ldelim(); + } + if (message.scratchNotes !== "") { + writer.uint32(154).string(message.scratchNotes); + } + if (message.inviteFriendCampaignSchedule !== undefined) { + InviteFriendCampaignSchedule.encode( + message.inviteFriendCampaignSchedule, + writer.uint32(218).fork() + ).ldelim(); + } + if (message.ghostSelectionMinRedoWait !== 0) { + writer.uint32(224).uint32(message.ghostSelectionMinRedoWait); + } + if (message.ghostSelectionMaxRedoWait !== 0) { + writer.uint32(232).uint32(message.ghostSelectionMaxRedoWait); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemInfoResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemInfoResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.regionId = reader.uint32(); + break; + case 3: + message.placeId = reader.string(); + break; + case 4: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.allowedClientLogTypes.push(reader.int32() as any); + } + } else { + message.allowedClientLogTypes.push(reader.int32() as any); + } + break; + case 10: + message.featureVersion = GameFeatureVersion.decode( + reader, + reader.uint32() + ); + break; + case 11: + message.latestCompetitionId = reader.uint32(); + break; + case 12: + message.competitionSchedule = GhostCompetitionSchedule.decode( + reader, + reader.uint32() + ); + break; + case 19: + message.scratchNotes = reader.string(); + break; + case 27: + message.inviteFriendCampaignSchedule = + InviteFriendCampaignSchedule.decode(reader, reader.uint32()); + break; + case 28: + message.ghostSelectionMinRedoWait = reader.uint32(); + break; + case 29: + message.ghostSelectionMaxRedoWait = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemInfoResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + placeId: isSet(object.placeId) ? String(object.placeId) : "", + allowedClientLogTypes: Array.isArray(object?.allowedClientLogTypes) + ? object.allowedClientLogTypes.map((e: any) => clientLogTypeFromJSON(e)) + : [], + featureVersion: isSet(object.featureVersion) + ? GameFeatureVersion.fromJSON(object.featureVersion) + : undefined, + latestCompetitionId: isSet(object.latestCompetitionId) + ? Number(object.latestCompetitionId) + : 0, + competitionSchedule: isSet(object.competitionSchedule) + ? GhostCompetitionSchedule.fromJSON(object.competitionSchedule) + : undefined, + scratchNotes: isSet(object.scratchNotes) + ? String(object.scratchNotes) + : "", + inviteFriendCampaignSchedule: isSet(object.inviteFriendCampaignSchedule) + ? InviteFriendCampaignSchedule.fromJSON( + object.inviteFriendCampaignSchedule + ) + : undefined, + ghostSelectionMinRedoWait: isSet(object.ghostSelectionMinRedoWait) + ? Number(object.ghostSelectionMinRedoWait) + : 0, + ghostSelectionMaxRedoWait: isSet(object.ghostSelectionMaxRedoWait) + ? Number(object.ghostSelectionMaxRedoWait) + : 0, + }; + }, + + toJSON(message: RegisterSystemInfoResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + message.placeId !== undefined && (obj.placeId = message.placeId); + if (message.allowedClientLogTypes) { + obj.allowedClientLogTypes = message.allowedClientLogTypes.map((e) => + clientLogTypeToJSON(e) + ); + } else { + obj.allowedClientLogTypes = []; + } + message.featureVersion !== undefined && + (obj.featureVersion = message.featureVersion + ? GameFeatureVersion.toJSON(message.featureVersion) + : undefined); + message.latestCompetitionId !== undefined && + (obj.latestCompetitionId = Math.round(message.latestCompetitionId)); + message.competitionSchedule !== undefined && + (obj.competitionSchedule = message.competitionSchedule + ? GhostCompetitionSchedule.toJSON(message.competitionSchedule) + : undefined); + message.scratchNotes !== undefined && + (obj.scratchNotes = message.scratchNotes); + message.inviteFriendCampaignSchedule !== undefined && + (obj.inviteFriendCampaignSchedule = message.inviteFriendCampaignSchedule + ? InviteFriendCampaignSchedule.toJSON( + message.inviteFriendCampaignSchedule + ) + : undefined); + message.ghostSelectionMinRedoWait !== undefined && + (obj.ghostSelectionMinRedoWait = Math.round( + message.ghostSelectionMinRedoWait + )); + message.ghostSelectionMaxRedoWait !== undefined && + (obj.ghostSelectionMaxRedoWait = Math.round( + message.ghostSelectionMaxRedoWait + )); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterSystemInfoResponse { + const message = createBaseRegisterSystemInfoResponse(); + message.error = object.error ?? 0; + message.regionId = object.regionId ?? 0; + message.placeId = object.placeId ?? ""; + message.allowedClientLogTypes = + object.allowedClientLogTypes?.map((e) => e) || []; + message.featureVersion = + object.featureVersion !== undefined && object.featureVersion !== null + ? GameFeatureVersion.fromPartial(object.featureVersion) + : undefined; + message.latestCompetitionId = object.latestCompetitionId ?? 0; + message.competitionSchedule = + object.competitionSchedule !== undefined && + object.competitionSchedule !== null + ? GhostCompetitionSchedule.fromPartial(object.competitionSchedule) + : undefined; + message.scratchNotes = object.scratchNotes ?? ""; + message.inviteFriendCampaignSchedule = + object.inviteFriendCampaignSchedule !== undefined && + object.inviteFriendCampaignSchedule !== null + ? InviteFriendCampaignSchedule.fromPartial( + object.inviteFriendCampaignSchedule + ) + : undefined; + message.ghostSelectionMinRedoWait = object.ghostSelectionMinRedoWait ?? 0; + message.ghostSelectionMaxRedoWait = object.ghostSelectionMaxRedoWait ?? 0; + return message; + }, +}; + +function createBaseRegisterSystemStatsRequest(): RegisterSystemStatsRequest { + return { pcbSerial: "", driveStats: undefined, terminalStats: undefined }; +} + +export const RegisterSystemStatsRequest = { + encode( + message: RegisterSystemStatsRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.pcbSerial !== "") { + writer.uint32(10).string(message.pcbSerial); + } + if (message.driveStats !== undefined) { + RegisterSystemStatsRequest_DriveStats.encode( + message.driveStats, + writer.uint32(18).fork() + ).ldelim(); + } + if (message.terminalStats !== undefined) { + RegisterSystemStatsRequest_TerminalStats.encode( + message.terminalStats, + writer.uint32(26).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemStatsRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemStatsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pcbSerial = reader.string(); + break; + case 2: + message.driveStats = RegisterSystemStatsRequest_DriveStats.decode( + reader, + reader.uint32() + ); + break; + case 3: + message.terminalStats = + RegisterSystemStatsRequest_TerminalStats.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemStatsRequest { + return { + pcbSerial: isSet(object.pcbSerial) ? String(object.pcbSerial) : "", + driveStats: isSet(object.driveStats) + ? RegisterSystemStatsRequest_DriveStats.fromJSON(object.driveStats) + : undefined, + terminalStats: isSet(object.terminalStats) + ? RegisterSystemStatsRequest_TerminalStats.fromJSON( + object.terminalStats + ) + : undefined, + }; + }, + + toJSON(message: RegisterSystemStatsRequest): unknown { + const obj: any = {}; + message.pcbSerial !== undefined && (obj.pcbSerial = message.pcbSerial); + message.driveStats !== undefined && + (obj.driveStats = message.driveStats + ? RegisterSystemStatsRequest_DriveStats.toJSON(message.driveStats) + : undefined); + message.terminalStats !== undefined && + (obj.terminalStats = message.terminalStats + ? RegisterSystemStatsRequest_TerminalStats.toJSON(message.terminalStats) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterSystemStatsRequest { + const message = createBaseRegisterSystemStatsRequest(); + message.pcbSerial = object.pcbSerial ?? ""; + message.driveStats = + object.driveStats !== undefined && object.driveStats !== null + ? RegisterSystemStatsRequest_DriveStats.fromPartial(object.driveStats) + : undefined; + message.terminalStats = + object.terminalStats !== undefined && object.terminalStats !== null + ? RegisterSystemStatsRequest_TerminalStats.fromPartial( + object.terminalStats + ) + : undefined; + return message; + }, +}; + +function createBaseRegisterSystemStatsRequest_DriveStats(): RegisterSystemStatsRequest_DriveStats { + return { + operation: [], + story: [], + versus: [], + ghost: [], + timeAttack: [], + event: [], + }; +} + +export const RegisterSystemStatsRequest_DriveStats = { + encode( + message: RegisterSystemStatsRequest_DriveStats, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + writer.uint32(10).fork(); + for (const v of message.operation) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(18).fork(); + for (const v of message.story) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(26).fork(); + for (const v of message.versus) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(34).fork(); + for (const v of message.ghost) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(42).fork(); + for (const v of message.timeAttack) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(50).fork(); + for (const v of message.event) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemStatsRequest_DriveStats { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemStatsRequest_DriveStats(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.operation.push(reader.uint32()); + } + } else { + message.operation.push(reader.uint32()); + } + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.story.push(reader.uint32()); + } + } else { + message.story.push(reader.uint32()); + } + break; + case 3: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.versus.push(reader.uint32()); + } + } else { + message.versus.push(reader.uint32()); + } + break; + case 4: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.ghost.push(reader.uint32()); + } + } else { + message.ghost.push(reader.uint32()); + } + break; + case 5: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.timeAttack.push(reader.uint32()); + } + } else { + message.timeAttack.push(reader.uint32()); + } + break; + case 6: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.event.push(reader.uint32()); + } + } else { + message.event.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemStatsRequest_DriveStats { + return { + operation: Array.isArray(object?.operation) + ? object.operation.map((e: any) => Number(e)) + : [], + story: Array.isArray(object?.story) + ? object.story.map((e: any) => Number(e)) + : [], + versus: Array.isArray(object?.versus) + ? object.versus.map((e: any) => Number(e)) + : [], + ghost: Array.isArray(object?.ghost) + ? object.ghost.map((e: any) => Number(e)) + : [], + timeAttack: Array.isArray(object?.timeAttack) + ? object.timeAttack.map((e: any) => Number(e)) + : [], + event: Array.isArray(object?.event) + ? object.event.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: RegisterSystemStatsRequest_DriveStats): unknown { + const obj: any = {}; + if (message.operation) { + obj.operation = message.operation.map((e) => Math.round(e)); + } else { + obj.operation = []; + } + if (message.story) { + obj.story = message.story.map((e) => Math.round(e)); + } else { + obj.story = []; + } + if (message.versus) { + obj.versus = message.versus.map((e) => Math.round(e)); + } else { + obj.versus = []; + } + if (message.ghost) { + obj.ghost = message.ghost.map((e) => Math.round(e)); + } else { + obj.ghost = []; + } + if (message.timeAttack) { + obj.timeAttack = message.timeAttack.map((e) => Math.round(e)); + } else { + obj.timeAttack = []; + } + if (message.event) { + obj.event = message.event.map((e) => Math.round(e)); + } else { + obj.event = []; + } + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): RegisterSystemStatsRequest_DriveStats { + const message = createBaseRegisterSystemStatsRequest_DriveStats(); + message.operation = object.operation?.map((e) => e) || []; + message.story = object.story?.map((e) => e) || []; + message.versus = object.versus?.map((e) => e) || []; + message.ghost = object.ghost?.map((e) => e) || []; + message.timeAttack = object.timeAttack?.map((e) => e) || []; + message.event = object.event?.map((e) => e) || []; + return message; + }, +}; + +function createBaseRegisterSystemStatsRequest_TerminalStats(): RegisterSystemStatsRequest_TerminalStats { + return { operation: [] }; +} + +export const RegisterSystemStatsRequest_TerminalStats = { + encode( + message: RegisterSystemStatsRequest_TerminalStats, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + writer.uint32(10).fork(); + for (const v of message.operation) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemStatsRequest_TerminalStats { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemStatsRequest_TerminalStats(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.operation.push(reader.uint32()); + } + } else { + message.operation.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemStatsRequest_TerminalStats { + return { + operation: Array.isArray(object?.operation) + ? object.operation.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: RegisterSystemStatsRequest_TerminalStats): unknown { + const obj: any = {}; + if (message.operation) { + obj.operation = message.operation.map((e) => Math.round(e)); + } else { + obj.operation = []; + } + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): RegisterSystemStatsRequest_TerminalStats { + const message = createBaseRegisterSystemStatsRequest_TerminalStats(); + message.operation = object.operation?.map((e) => e) || []; + return message; + }, +}; + +function createBaseRegisterSystemStatsResponse(): RegisterSystemStatsResponse { + return { error: 0 }; +} + +export const RegisterSystemStatsResponse = { + encode( + message: RegisterSystemStatsResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterSystemStatsResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterSystemStatsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterSystemStatsResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: RegisterSystemStatsResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterSystemStatsResponse { + const message = createBaseRegisterSystemStatsResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseRegisterGhostTrailRequest(): RegisterGhostTrailRequest { + return { + ghostSessionId: 0, + ghost: undefined, + trail: Buffer.alloc(0), + time: 0, + driveData: undefined, + trendBinaryByArea: undefined, + trendBinaryByCar: undefined, + trendBinaryByUser: undefined, + }; +} + +export const RegisterGhostTrailRequest = { + encode( + message: RegisterGhostTrailRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.ghostSessionId !== 0) { + writer.uint32(8).uint64(message.ghostSessionId); + } + if (message.ghost !== undefined) { + GhostCar.encode(message.ghost, writer.uint32(18).fork()).ldelim(); + } + if (message.trail.length !== 0) { + writer.uint32(26).bytes(message.trail); + } + if (message.time !== 0) { + writer.uint32(32).uint32(message.time); + } + if (message.driveData !== undefined) { + BinaryData.encode(message.driveData, writer.uint32(42).fork()).ldelim(); + } + if (message.trendBinaryByArea !== undefined) { + BinaryData.encode( + message.trendBinaryByArea, + writer.uint32(50).fork() + ).ldelim(); + } + if (message.trendBinaryByCar !== undefined) { + BinaryData.encode( + message.trendBinaryByCar, + writer.uint32(58).fork() + ).ldelim(); + } + if (message.trendBinaryByUser !== undefined) { + BinaryData.encode( + message.trendBinaryByUser, + writer.uint32(66).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterGhostTrailRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterGhostTrailRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.ghostSessionId = longToNumber(reader.uint64() as Long); + break; + case 2: + message.ghost = GhostCar.decode(reader, reader.uint32()); + break; + case 3: + message.trail = reader.bytes() as Buffer; + break; + case 4: + message.time = reader.uint32(); + break; + case 5: + message.driveData = BinaryData.decode(reader, reader.uint32()); + break; + case 6: + message.trendBinaryByArea = BinaryData.decode( + reader, + reader.uint32() + ); + break; + case 7: + message.trendBinaryByCar = BinaryData.decode(reader, reader.uint32()); + break; + case 8: + message.trendBinaryByUser = BinaryData.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterGhostTrailRequest { + return { + ghostSessionId: isSet(object.ghostSessionId) + ? Number(object.ghostSessionId) + : 0, + ghost: isSet(object.ghost) ? GhostCar.fromJSON(object.ghost) : undefined, + trail: isSet(object.trail) + ? Buffer.from(bytesFromBase64(object.trail)) + : Buffer.alloc(0), + time: isSet(object.time) ? Number(object.time) : 0, + driveData: isSet(object.driveData) + ? BinaryData.fromJSON(object.driveData) + : undefined, + trendBinaryByArea: isSet(object.trendBinaryByArea) + ? BinaryData.fromJSON(object.trendBinaryByArea) + : undefined, + trendBinaryByCar: isSet(object.trendBinaryByCar) + ? BinaryData.fromJSON(object.trendBinaryByCar) + : undefined, + trendBinaryByUser: isSet(object.trendBinaryByUser) + ? BinaryData.fromJSON(object.trendBinaryByUser) + : undefined, + }; + }, + + toJSON(message: RegisterGhostTrailRequest): unknown { + const obj: any = {}; + message.ghostSessionId !== undefined && + (obj.ghostSessionId = Math.round(message.ghostSessionId)); + message.ghost !== undefined && + (obj.ghost = message.ghost ? GhostCar.toJSON(message.ghost) : undefined); + message.trail !== undefined && + (obj.trail = base64FromBytes( + message.trail !== undefined ? message.trail : Buffer.alloc(0) + )); + message.time !== undefined && (obj.time = Math.round(message.time)); + message.driveData !== undefined && + (obj.driveData = message.driveData + ? BinaryData.toJSON(message.driveData) + : undefined); + message.trendBinaryByArea !== undefined && + (obj.trendBinaryByArea = message.trendBinaryByArea + ? BinaryData.toJSON(message.trendBinaryByArea) + : undefined); + message.trendBinaryByCar !== undefined && + (obj.trendBinaryByCar = message.trendBinaryByCar + ? BinaryData.toJSON(message.trendBinaryByCar) + : undefined); + message.trendBinaryByUser !== undefined && + (obj.trendBinaryByUser = message.trendBinaryByUser + ? BinaryData.toJSON(message.trendBinaryByUser) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterGhostTrailRequest { + const message = createBaseRegisterGhostTrailRequest(); + message.ghostSessionId = object.ghostSessionId ?? 0; + message.ghost = + object.ghost !== undefined && object.ghost !== null + ? GhostCar.fromPartial(object.ghost) + : undefined; + message.trail = object.trail ?? Buffer.alloc(0); + message.time = object.time ?? 0; + message.driveData = + object.driveData !== undefined && object.driveData !== null + ? BinaryData.fromPartial(object.driveData) + : undefined; + message.trendBinaryByArea = + object.trendBinaryByArea !== undefined && + object.trendBinaryByArea !== null + ? BinaryData.fromPartial(object.trendBinaryByArea) + : undefined; + message.trendBinaryByCar = + object.trendBinaryByCar !== undefined && object.trendBinaryByCar !== null + ? BinaryData.fromPartial(object.trendBinaryByCar) + : undefined; + message.trendBinaryByUser = + object.trendBinaryByUser !== undefined && + object.trendBinaryByUser !== null + ? BinaryData.fromPartial(object.trendBinaryByUser) + : undefined; + return message; + }, +}; + +function createBaseRegisterGhostTrailResponse(): RegisterGhostTrailResponse { + return { error: 0 }; +} + +export const RegisterGhostTrailResponse = { + encode( + message: RegisterGhostTrailResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterGhostTrailResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterGhostTrailResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterGhostTrailResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: RegisterGhostTrailResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterGhostTrailResponse { + const message = createBaseRegisterGhostTrailResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseLoadUserRequest(): LoadUserRequest { + return { + cardChipId: "", + accessCode: "", + cardTypeCode: 0, + cardRegionCode: 0, + device: 0, + userId: 0, + romVersion: 0, + maxCars: 0, + createUser: false, + }; +} + +export const LoadUserRequest = { + encode( + message: LoadUserRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.cardChipId !== "") { + writer.uint32(10).string(message.cardChipId); + } + if (message.accessCode !== "") { + writer.uint32(18).string(message.accessCode); + } + if (message.cardTypeCode !== 0) { + writer.uint32(24).uint32(message.cardTypeCode); + } + if (message.cardRegionCode !== 0) { + writer.uint32(32).uint32(message.cardRegionCode); + } + if (message.device !== 0) { + writer.uint32(40).int32(message.device); + } + if (message.userId !== 0) { + writer.uint32(48).uint32(message.userId); + } + if (message.romVersion !== 0) { + writer.uint32(56).uint32(message.romVersion); + } + if (message.maxCars !== 0) { + writer.uint32(64).uint32(message.maxCars); + } + if (message.createUser === true) { + writer.uint32(72).bool(message.createUser); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): LoadUserRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadUserRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.cardChipId = reader.string(); + break; + case 2: + message.accessCode = reader.string(); + break; + case 3: + message.cardTypeCode = reader.uint32(); + break; + case 4: + message.cardRegionCode = reader.uint32(); + break; + case 5: + message.device = reader.int32() as any; + break; + case 6: + message.userId = reader.uint32(); + break; + case 7: + message.romVersion = reader.uint32(); + break; + case 8: + message.maxCars = reader.uint32(); + break; + case 9: + message.createUser = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadUserRequest { + return { + cardChipId: isSet(object.cardChipId) ? String(object.cardChipId) : "", + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + cardTypeCode: isSet(object.cardTypeCode) + ? Number(object.cardTypeCode) + : 0, + cardRegionCode: isSet(object.cardRegionCode) + ? Number(object.cardRegionCode) + : 0, + device: isSet(object.device) ? deviceTypeFromJSON(object.device) : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + romVersion: isSet(object.romVersion) ? Number(object.romVersion) : 0, + maxCars: isSet(object.maxCars) ? Number(object.maxCars) : 0, + createUser: isSet(object.createUser) ? Boolean(object.createUser) : false, + }; + }, + + toJSON(message: LoadUserRequest): unknown { + const obj: any = {}; + message.cardChipId !== undefined && (obj.cardChipId = message.cardChipId); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.cardTypeCode !== undefined && + (obj.cardTypeCode = Math.round(message.cardTypeCode)); + message.cardRegionCode !== undefined && + (obj.cardRegionCode = Math.round(message.cardRegionCode)); + message.device !== undefined && + (obj.device = deviceTypeToJSON(message.device)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.romVersion !== undefined && + (obj.romVersion = Math.round(message.romVersion)); + message.maxCars !== undefined && + (obj.maxCars = Math.round(message.maxCars)); + message.createUser !== undefined && (obj.createUser = message.createUser); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadUserRequest { + const message = createBaseLoadUserRequest(); + message.cardChipId = object.cardChipId ?? ""; + message.accessCode = object.accessCode ?? ""; + message.cardTypeCode = object.cardTypeCode ?? 0; + message.cardRegionCode = object.cardRegionCode ?? 0; + message.device = object.device ?? 0; + message.userId = object.userId ?? 0; + message.romVersion = object.romVersion ?? 0; + message.maxCars = object.maxCars ?? 0; + message.createUser = object.createUser ?? false; + return message; + }, +}; + +function createBaseLoadUserResponse(): LoadUserResponse { + return { + error: 0, + unlockAt: 0, + accessCode: "", + banapassportAmId: 0, + mbid: 0, + userId: 0, + numOfOwnedCars: 0, + cars: [], + carStates: [], + unusedCarTickets: [], + tutorials: [], + competitionUserState: 1, + windowStickerString: "", + windowStickerFont: 0, + spappState: 0, + transferState: 0, + totalVsStarCount: 0, + totalVsMedalPoint: 0, + copiedCar: undefined, + wasCreatedToday: false, + participatedInInviteFriendCampaign: false, + }; +} + +export const LoadUserResponse = { + encode( + message: LoadUserResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.unlockAt !== 0) { + writer.uint32(16).uint32(message.unlockAt); + } + if (message.accessCode !== "") { + writer.uint32(26).string(message.accessCode); + } + if (message.banapassportAmId !== 0) { + writer.uint32(32).uint32(message.banapassportAmId); + } + if (message.mbid !== 0) { + writer.uint32(40).uint32(message.mbid); + } + if (message.userId !== 0) { + writer.uint32(48).uint32(message.userId); + } + if (message.numOfOwnedCars !== 0) { + writer.uint32(80).uint32(message.numOfOwnedCars); + } + for (const v of message.cars) { + Car.encode(v!, writer.uint32(90).fork()).ldelim(); + } + for (const v of message.carStates) { + LoadUserResponse_CarState.encode(v!, writer.uint32(98).fork()).ldelim(); + } + for (const v of message.unusedCarTickets) { + UserItem.encode(v!, writer.uint32(106).fork()).ldelim(); + } + writer.uint32(122).fork(); + for (const v of message.tutorials) { + writer.bool(v); + } + writer.ldelim(); + if (message.competitionUserState !== 1) { + writer.uint32(136).int32(message.competitionUserState); + } + if (message.windowStickerString !== "") { + writer.uint32(154).string(message.windowStickerString); + } + if (message.windowStickerFont !== 0) { + writer.uint32(160).uint32(message.windowStickerFont); + } + if (message.spappState !== 0) { + writer.uint32(168).int32(message.spappState); + } + if (message.transferState !== 0) { + writer.uint32(176).int32(message.transferState); + } + if (message.totalVsStarCount !== 0) { + writer.uint32(200).uint32(message.totalVsStarCount); + } + if (message.totalVsMedalPoint !== 0) { + writer.uint32(208).uint32(message.totalVsMedalPoint); + } + if (message.copiedCar !== undefined) { + CopiedCar.encode(message.copiedCar, writer.uint32(218).fork()).ldelim(); + } + if (message.wasCreatedToday === true) { + writer.uint32(224).bool(message.wasCreatedToday); + } + if (message.participatedInInviteFriendCampaign === true) { + writer.uint32(232).bool(message.participatedInInviteFriendCampaign); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): LoadUserResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadUserResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.unlockAt = reader.uint32(); + break; + case 3: + message.accessCode = reader.string(); + break; + case 4: + message.banapassportAmId = reader.uint32(); + break; + case 5: + message.mbid = reader.uint32(); + break; + case 6: + message.userId = reader.uint32(); + break; + case 10: + message.numOfOwnedCars = reader.uint32(); + break; + case 11: + message.cars.push(Car.decode(reader, reader.uint32())); + break; + case 12: + message.carStates.push( + LoadUserResponse_CarState.decode(reader, reader.uint32()) + ); + break; + case 13: + message.unusedCarTickets.push( + UserItem.decode(reader, reader.uint32()) + ); + break; + case 15: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.tutorials.push(reader.bool()); + } + } else { + message.tutorials.push(reader.bool()); + } + break; + case 17: + message.competitionUserState = reader.int32() as any; + break; + case 19: + message.windowStickerString = reader.string(); + break; + case 20: + message.windowStickerFont = reader.uint32(); + break; + case 21: + message.spappState = reader.int32() as any; + break; + case 22: + message.transferState = reader.int32() as any; + break; + case 25: + message.totalVsStarCount = reader.uint32(); + break; + case 26: + message.totalVsMedalPoint = reader.uint32(); + break; + case 27: + message.copiedCar = CopiedCar.decode(reader, reader.uint32()); + break; + case 28: + message.wasCreatedToday = reader.bool(); + break; + case 29: + message.participatedInInviteFriendCampaign = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadUserResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + unlockAt: isSet(object.unlockAt) ? Number(object.unlockAt) : 0, + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + banapassportAmId: isSet(object.banapassportAmId) + ? Number(object.banapassportAmId) + : 0, + mbid: isSet(object.mbid) ? Number(object.mbid) : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + numOfOwnedCars: isSet(object.numOfOwnedCars) + ? Number(object.numOfOwnedCars) + : 0, + cars: Array.isArray(object?.cars) + ? object.cars.map((e: any) => Car.fromJSON(e)) + : [], + carStates: Array.isArray(object?.carStates) + ? object.carStates.map((e: any) => + LoadUserResponse_CarState.fromJSON(e) + ) + : [], + unusedCarTickets: Array.isArray(object?.unusedCarTickets) + ? object.unusedCarTickets.map((e: any) => UserItem.fromJSON(e)) + : [], + tutorials: Array.isArray(object?.tutorials) + ? object.tutorials.map((e: any) => Boolean(e)) + : [], + competitionUserState: isSet(object.competitionUserState) + ? ghostCompetitionParticipantStateFromJSON(object.competitionUserState) + : 1, + windowStickerString: isSet(object.windowStickerString) + ? String(object.windowStickerString) + : "", + windowStickerFont: isSet(object.windowStickerFont) + ? Number(object.windowStickerFont) + : 0, + spappState: isSet(object.spappState) + ? smartphoneAppStateFromJSON(object.spappState) + : 0, + transferState: isSet(object.transferState) + ? transferStateFromJSON(object.transferState) + : 0, + totalVsStarCount: isSet(object.totalVsStarCount) + ? Number(object.totalVsStarCount) + : 0, + totalVsMedalPoint: isSet(object.totalVsMedalPoint) + ? Number(object.totalVsMedalPoint) + : 0, + copiedCar: isSet(object.copiedCar) + ? CopiedCar.fromJSON(object.copiedCar) + : undefined, + wasCreatedToday: isSet(object.wasCreatedToday) + ? Boolean(object.wasCreatedToday) + : false, + participatedInInviteFriendCampaign: isSet( + object.participatedInInviteFriendCampaign + ) + ? Boolean(object.participatedInInviteFriendCampaign) + : false, + }; + }, + + toJSON(message: LoadUserResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.unlockAt !== undefined && + (obj.unlockAt = Math.round(message.unlockAt)); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.banapassportAmId !== undefined && + (obj.banapassportAmId = Math.round(message.banapassportAmId)); + message.mbid !== undefined && (obj.mbid = Math.round(message.mbid)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.numOfOwnedCars !== undefined && + (obj.numOfOwnedCars = Math.round(message.numOfOwnedCars)); + if (message.cars) { + obj.cars = message.cars.map((e) => (e ? Car.toJSON(e) : undefined)); + } else { + obj.cars = []; + } + if (message.carStates) { + obj.carStates = message.carStates.map((e) => + e ? LoadUserResponse_CarState.toJSON(e) : undefined + ); + } else { + obj.carStates = []; + } + if (message.unusedCarTickets) { + obj.unusedCarTickets = message.unusedCarTickets.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.unusedCarTickets = []; + } + if (message.tutorials) { + obj.tutorials = message.tutorials.map((e) => e); + } else { + obj.tutorials = []; + } + message.competitionUserState !== undefined && + (obj.competitionUserState = ghostCompetitionParticipantStateToJSON( + message.competitionUserState + )); + message.windowStickerString !== undefined && + (obj.windowStickerString = message.windowStickerString); + message.windowStickerFont !== undefined && + (obj.windowStickerFont = Math.round(message.windowStickerFont)); + message.spappState !== undefined && + (obj.spappState = smartphoneAppStateToJSON(message.spappState)); + message.transferState !== undefined && + (obj.transferState = transferStateToJSON(message.transferState)); + message.totalVsStarCount !== undefined && + (obj.totalVsStarCount = Math.round(message.totalVsStarCount)); + message.totalVsMedalPoint !== undefined && + (obj.totalVsMedalPoint = Math.round(message.totalVsMedalPoint)); + message.copiedCar !== undefined && + (obj.copiedCar = message.copiedCar + ? CopiedCar.toJSON(message.copiedCar) + : undefined); + message.wasCreatedToday !== undefined && + (obj.wasCreatedToday = message.wasCreatedToday); + message.participatedInInviteFriendCampaign !== undefined && + (obj.participatedInInviteFriendCampaign = + message.participatedInInviteFriendCampaign); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadUserResponse { + const message = createBaseLoadUserResponse(); + message.error = object.error ?? 0; + message.unlockAt = object.unlockAt ?? 0; + message.accessCode = object.accessCode ?? ""; + message.banapassportAmId = object.banapassportAmId ?? 0; + message.mbid = object.mbid ?? 0; + message.userId = object.userId ?? 0; + message.numOfOwnedCars = object.numOfOwnedCars ?? 0; + message.cars = object.cars?.map((e) => Car.fromPartial(e)) || []; + message.carStates = + object.carStates?.map((e) => LoadUserResponse_CarState.fromPartial(e)) || + []; + message.unusedCarTickets = + object.unusedCarTickets?.map((e) => UserItem.fromPartial(e)) || []; + message.tutorials = object.tutorials?.map((e) => e) || []; + message.competitionUserState = object.competitionUserState ?? 1; + message.windowStickerString = object.windowStickerString ?? ""; + message.windowStickerFont = object.windowStickerFont ?? 0; + message.spappState = object.spappState ?? 0; + message.transferState = object.transferState ?? 0; + message.totalVsStarCount = object.totalVsStarCount ?? 0; + message.totalVsMedalPoint = object.totalVsMedalPoint ?? 0; + message.copiedCar = + object.copiedCar !== undefined && object.copiedCar !== null + ? CopiedCar.fromPartial(object.copiedCar) + : undefined; + message.wasCreatedToday = object.wasCreatedToday ?? false; + message.participatedInInviteFriendCampaign = + object.participatedInInviteFriendCampaign ?? false; + return message; + }, +}; + +function createBaseLoadUserResponse_CarState(): LoadUserResponse_CarState { + return { + hasOpponentGhost: false, + competitionState: 1, + toBeDeleted: false, + eventJoined: false, + transferred: false, + driveLastPlayedAt: 0, + }; +} + +export const LoadUserResponse_CarState = { + encode( + message: LoadUserResponse_CarState, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.hasOpponentGhost === true) { + writer.uint32(8).bool(message.hasOpponentGhost); + } + if (message.competitionState !== 1) { + writer.uint32(16).int32(message.competitionState); + } + if (message.toBeDeleted === true) { + writer.uint32(32).bool(message.toBeDeleted); + } + if (message.eventJoined === true) { + writer.uint32(40).bool(message.eventJoined); + } + if (message.transferred === true) { + writer.uint32(48).bool(message.transferred); + } + if (message.driveLastPlayedAt !== 0) { + writer.uint32(56).uint32(message.driveLastPlayedAt); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadUserResponse_CarState { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadUserResponse_CarState(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.hasOpponentGhost = reader.bool(); + break; + case 2: + message.competitionState = reader.int32() as any; + break; + case 4: + message.toBeDeleted = reader.bool(); + break; + case 5: + message.eventJoined = reader.bool(); + break; + case 6: + message.transferred = reader.bool(); + break; + case 7: + message.driveLastPlayedAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadUserResponse_CarState { + return { + hasOpponentGhost: isSet(object.hasOpponentGhost) + ? Boolean(object.hasOpponentGhost) + : false, + competitionState: isSet(object.competitionState) + ? ghostCompetitionParticipantStateFromJSON(object.competitionState) + : 1, + toBeDeleted: isSet(object.toBeDeleted) + ? Boolean(object.toBeDeleted) + : false, + eventJoined: isSet(object.eventJoined) + ? Boolean(object.eventJoined) + : false, + transferred: isSet(object.transferred) + ? Boolean(object.transferred) + : false, + driveLastPlayedAt: isSet(object.driveLastPlayedAt) + ? Number(object.driveLastPlayedAt) + : 0, + }; + }, + + toJSON(message: LoadUserResponse_CarState): unknown { + const obj: any = {}; + message.hasOpponentGhost !== undefined && + (obj.hasOpponentGhost = message.hasOpponentGhost); + message.competitionState !== undefined && + (obj.competitionState = ghostCompetitionParticipantStateToJSON( + message.competitionState + )); + message.toBeDeleted !== undefined && + (obj.toBeDeleted = message.toBeDeleted); + message.eventJoined !== undefined && + (obj.eventJoined = message.eventJoined); + message.transferred !== undefined && + (obj.transferred = message.transferred); + message.driveLastPlayedAt !== undefined && + (obj.driveLastPlayedAt = Math.round(message.driveLastPlayedAt)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadUserResponse_CarState { + const message = createBaseLoadUserResponse_CarState(); + message.hasOpponentGhost = object.hasOpponentGhost ?? false; + message.competitionState = object.competitionState ?? 1; + message.toBeDeleted = object.toBeDeleted ?? false; + message.eventJoined = object.eventJoined ?? false; + message.transferred = object.transferred ?? false; + message.driveLastPlayedAt = object.driveLastPlayedAt ?? 0; + return message; + }, +}; + +function createBaseUpdateUserSessionRequest(): UpdateUserSessionRequest { + return { + userId: 0, + cardChipId: "", + accessCode: "", + cardTypeCode: 0, + cardRegionCode: 0, + device: 0, + unlockAt: 0, + acceptVs: false, + }; +} + +export const UpdateUserSessionRequest = { + encode( + message: UpdateUserSessionRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + if (message.cardChipId !== "") { + writer.uint32(18).string(message.cardChipId); + } + if (message.accessCode !== "") { + writer.uint32(26).string(message.accessCode); + } + if (message.cardTypeCode !== 0) { + writer.uint32(32).uint32(message.cardTypeCode); + } + if (message.cardRegionCode !== 0) { + writer.uint32(40).uint32(message.cardRegionCode); + } + if (message.device !== 0) { + writer.uint32(48).int32(message.device); + } + if (message.unlockAt !== 0) { + writer.uint32(56).uint32(message.unlockAt); + } + if (message.acceptVs === true) { + writer.uint32(64).bool(message.acceptVs); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): UpdateUserSessionRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateUserSessionRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.cardChipId = reader.string(); + break; + case 3: + message.accessCode = reader.string(); + break; + case 4: + message.cardTypeCode = reader.uint32(); + break; + case 5: + message.cardRegionCode = reader.uint32(); + break; + case 6: + message.device = reader.int32() as any; + break; + case 7: + message.unlockAt = reader.uint32(); + break; + case 8: + message.acceptVs = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpdateUserSessionRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + cardChipId: isSet(object.cardChipId) ? String(object.cardChipId) : "", + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + cardTypeCode: isSet(object.cardTypeCode) + ? Number(object.cardTypeCode) + : 0, + cardRegionCode: isSet(object.cardRegionCode) + ? Number(object.cardRegionCode) + : 0, + device: isSet(object.device) ? deviceTypeFromJSON(object.device) : 0, + unlockAt: isSet(object.unlockAt) ? Number(object.unlockAt) : 0, + acceptVs: isSet(object.acceptVs) ? Boolean(object.acceptVs) : false, + }; + }, + + toJSON(message: UpdateUserSessionRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.cardChipId !== undefined && (obj.cardChipId = message.cardChipId); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.cardTypeCode !== undefined && + (obj.cardTypeCode = Math.round(message.cardTypeCode)); + message.cardRegionCode !== undefined && + (obj.cardRegionCode = Math.round(message.cardRegionCode)); + message.device !== undefined && + (obj.device = deviceTypeToJSON(message.device)); + message.unlockAt !== undefined && + (obj.unlockAt = Math.round(message.unlockAt)); + message.acceptVs !== undefined && (obj.acceptVs = message.acceptVs); + return obj; + }, + + fromPartial, I>>( + object: I + ): UpdateUserSessionRequest { + const message = createBaseUpdateUserSessionRequest(); + message.userId = object.userId ?? 0; + message.cardChipId = object.cardChipId ?? ""; + message.accessCode = object.accessCode ?? ""; + message.cardTypeCode = object.cardTypeCode ?? 0; + message.cardRegionCode = object.cardRegionCode ?? 0; + message.device = object.device ?? 0; + message.unlockAt = object.unlockAt ?? 0; + message.acceptVs = object.acceptVs ?? false; + return message; + }, +}; + +function createBaseUpdateUserSessionResponse(): UpdateUserSessionResponse { + return { error: 0 }; +} + +export const UpdateUserSessionResponse = { + encode( + message: UpdateUserSessionResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): UpdateUserSessionResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateUserSessionResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpdateUserSessionResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: UpdateUserSessionResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): UpdateUserSessionResponse { + const message = createBaseUpdateUserSessionResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseLoadDriveInformationRequest(): LoadDriveInformationRequest { + return { userId: 0 }; +} + +export const LoadDriveInformationRequest = { + encode( + message: LoadDriveInformationRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadDriveInformationRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadDriveInformationRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadDriveInformationRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: LoadDriveInformationRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadDriveInformationRequest { + const message = createBaseLoadDriveInformationRequest(); + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseLoadDriveInformationResponse(): LoadDriveInformationResponse { + return { + error: 0, + noticeWindow: [], + noticeWindowMessage: [], + transferNotice: undefined, + restrictedModels: [], + announceFeature: false, + announceMobile: false, + availableTickets: [], + }; +} + +export const LoadDriveInformationResponse = { + encode( + message: LoadDriveInformationResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + writer.uint32(18).fork(); + for (const v of message.noticeWindow) { + writer.int32(v); + } + writer.ldelim(); + for (const v of message.noticeWindowMessage) { + writer.uint32(26).string(v!); + } + if (message.transferNotice !== undefined) { + TransferNotice.encode( + message.transferNotice, + writer.uint32(34).fork() + ).ldelim(); + } + writer.uint32(50).fork(); + for (const v of message.restrictedModels) { + writer.uint32(v); + } + writer.ldelim(); + if (message.announceFeature === true) { + writer.uint32(56).bool(message.announceFeature); + } + if (message.announceMobile === true) { + writer.uint32(64).bool(message.announceMobile); + } + for (const v of message.availableTickets) { + UserItem.encode(v!, writer.uint32(74).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadDriveInformationResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadDriveInformationResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.noticeWindow.push(reader.int32() as any); + } + } else { + message.noticeWindow.push(reader.int32() as any); + } + break; + case 3: + message.noticeWindowMessage.push(reader.string()); + break; + case 4: + message.transferNotice = TransferNotice.decode( + reader, + reader.uint32() + ); + break; + case 6: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.restrictedModels.push(reader.uint32()); + } + } else { + message.restrictedModels.push(reader.uint32()); + } + break; + case 7: + message.announceFeature = reader.bool(); + break; + case 8: + message.announceMobile = reader.bool(); + break; + case 9: + message.availableTickets.push( + UserItem.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadDriveInformationResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + noticeWindow: Array.isArray(object?.noticeWindow) + ? object.noticeWindow.map((e: any) => noticeEntryFromJSON(e)) + : [], + noticeWindowMessage: Array.isArray(object?.noticeWindowMessage) + ? object.noticeWindowMessage.map((e: any) => String(e)) + : [], + transferNotice: isSet(object.transferNotice) + ? TransferNotice.fromJSON(object.transferNotice) + : undefined, + restrictedModels: Array.isArray(object?.restrictedModels) + ? object.restrictedModels.map((e: any) => Number(e)) + : [], + announceFeature: isSet(object.announceFeature) + ? Boolean(object.announceFeature) + : false, + announceMobile: isSet(object.announceMobile) + ? Boolean(object.announceMobile) + : false, + availableTickets: Array.isArray(object?.availableTickets) + ? object.availableTickets.map((e: any) => UserItem.fromJSON(e)) + : [], + }; + }, + + toJSON(message: LoadDriveInformationResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.noticeWindow) { + obj.noticeWindow = message.noticeWindow.map((e) => noticeEntryToJSON(e)); + } else { + obj.noticeWindow = []; + } + if (message.noticeWindowMessage) { + obj.noticeWindowMessage = message.noticeWindowMessage.map((e) => e); + } else { + obj.noticeWindowMessage = []; + } + message.transferNotice !== undefined && + (obj.transferNotice = message.transferNotice + ? TransferNotice.toJSON(message.transferNotice) + : undefined); + if (message.restrictedModels) { + obj.restrictedModels = message.restrictedModels.map((e) => Math.round(e)); + } else { + obj.restrictedModels = []; + } + message.announceFeature !== undefined && + (obj.announceFeature = message.announceFeature); + message.announceMobile !== undefined && + (obj.announceMobile = message.announceMobile); + if (message.availableTickets) { + obj.availableTickets = message.availableTickets.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.availableTickets = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadDriveInformationResponse { + const message = createBaseLoadDriveInformationResponse(); + message.error = object.error ?? 0; + message.noticeWindow = object.noticeWindow?.map((e) => e) || []; + message.noticeWindowMessage = + object.noticeWindowMessage?.map((e) => e) || []; + message.transferNotice = + object.transferNotice !== undefined && object.transferNotice !== null + ? TransferNotice.fromPartial(object.transferNotice) + : undefined; + message.restrictedModels = object.restrictedModels?.map((e) => e) || []; + message.announceFeature = object.announceFeature ?? false; + message.announceMobile = object.announceMobile ?? false; + message.availableTickets = + object.availableTickets?.map((e) => UserItem.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseLoadCarRequest(): LoadCarRequest { + return { carId: 0, eventMode: false, eventModeSerial: "" }; +} + +export const LoadCarRequest = { + encode( + message: LoadCarRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.eventMode === true) { + writer.uint32(16).bool(message.eventMode); + } + if (message.eventModeSerial !== "") { + writer.uint32(26).string(message.eventModeSerial); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): LoadCarRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadCarRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.eventMode = reader.bool(); + break; + case 3: + message.eventModeSerial = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadCarRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + eventMode: isSet(object.eventMode) ? Boolean(object.eventMode) : false, + eventModeSerial: isSet(object.eventModeSerial) + ? String(object.eventModeSerial) + : "", + }; + }, + + toJSON(message: LoadCarRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.eventMode !== undefined && (obj.eventMode = message.eventMode); + message.eventModeSerial !== undefined && + (obj.eventModeSerial = message.eventModeSerial); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadCarRequest { + const message = createBaseLoadCarRequest(); + message.carId = object.carId ?? 0; + message.eventMode = object.eventMode ?? false; + message.eventModeSerial = object.eventModeSerial ?? ""; + return message; + }, +}; + +function createBaseLoadCarResponse(): LoadCarResponse { + return { + error: 0, + car: undefined, + tuningPoint: 0, + odometer: 0, + playCount: 0, + earnedCustomColor: false, + setting: undefined, + vsPlayCount: 0, + vsBurstCount: 0, + vsStarCount: 0, + vsStarCountMax: 0, + vsCoolOrWild: 0, + vsSmoothOrRough: 0, + vsTripleStarMedals: 0, + vsDoubleStarMedals: 0, + vsSingleStarMedals: 0, + vsPlainMedals: 0, + rgPlayCount: 0, + rgWinCount: 0, + rgTrophy: 0, + rgPreviousVersionPlayCount: 0, + rgScore: 0, + rgRegionMapScore: [], + rgRegions: [], + rgStamp: 0, + rgAcquireAllCrowns: false, + dressupLevel: 0, + dressupPoint: 0, + stPlayCount: 0, + stClearBits: 0, + stClearDivCount: 0, + stClearCount: 0, + stLoseBits: 0, + stConsecutiveWins: 0, + stConsecutiveWinsMax: 0, + stCompleted100Episodes: false, + challenger: undefined, + challengerReturnCount: 0, + numOfChallengers: 0, + opponentGhost: undefined, + opponentTrailId: 0, + opponentCompetitionId: 0, + competitionParameter: undefined, + specialTitles: [], + earnedTitles: [], + ownedItems: [], + auraMotifAutoChange: false, + screenshotCount: 0, + announceEventModePrize: false, + transferred: false, + driveLastPlayedAt: 0, + insurance: undefined, + }; +} + +export const LoadCarResponse = { + encode( + message: LoadCarResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(18).fork()).ldelim(); + } + if (message.tuningPoint !== 0) { + writer.uint32(24).uint32(message.tuningPoint); + } + if (message.odometer !== 0) { + writer.uint32(48).uint32(message.odometer); + } + if (message.playCount !== 0) { + writer.uint32(56).uint32(message.playCount); + } + if (message.earnedCustomColor === true) { + writer.uint32(64).bool(message.earnedCustomColor); + } + if (message.setting !== undefined) { + CarSetting.encode(message.setting, writer.uint32(82).fork()).ldelim(); + } + if (message.vsPlayCount !== 0) { + writer.uint32(96).uint32(message.vsPlayCount); + } + if (message.vsBurstCount !== 0) { + writer.uint32(104).uint32(message.vsBurstCount); + } + if (message.vsStarCount !== 0) { + writer.uint32(112).uint32(message.vsStarCount); + } + if (message.vsStarCountMax !== 0) { + writer.uint32(120).uint32(message.vsStarCountMax); + } + if (message.vsCoolOrWild !== 0) { + writer.uint32(128).sint32(message.vsCoolOrWild); + } + if (message.vsSmoothOrRough !== 0) { + writer.uint32(136).sint32(message.vsSmoothOrRough); + } + if (message.vsTripleStarMedals !== 0) { + writer.uint32(144).uint32(message.vsTripleStarMedals); + } + if (message.vsDoubleStarMedals !== 0) { + writer.uint32(152).uint32(message.vsDoubleStarMedals); + } + if (message.vsSingleStarMedals !== 0) { + writer.uint32(160).uint32(message.vsSingleStarMedals); + } + if (message.vsPlainMedals !== 0) { + writer.uint32(168).uint32(message.vsPlainMedals); + } + if (message.rgPlayCount !== 0) { + writer.uint32(176).uint32(message.rgPlayCount); + } + if (message.rgWinCount !== 0) { + writer.uint32(184).uint32(message.rgWinCount); + } + if (message.rgTrophy !== 0) { + writer.uint32(192).uint32(message.rgTrophy); + } + if (message.rgPreviousVersionPlayCount !== 0) { + writer.uint32(512).uint32(message.rgPreviousVersionPlayCount); + } + if (message.rgScore !== 0) { + writer.uint32(200).uint32(message.rgScore); + } + writer.uint32(210).fork(); + for (const v of message.rgRegionMapScore) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(242).fork(); + for (const v of message.rgRegions) { + writer.uint32(v); + } + writer.ldelim(); + if (message.rgStamp !== 0) { + writer.uint32(216).uint32(message.rgStamp); + } + if (message.rgAcquireAllCrowns === true) { + writer.uint32(472).bool(message.rgAcquireAllCrowns); + } + if (message.dressupLevel !== 0) { + writer.uint32(224).uint32(message.dressupLevel); + } + if (message.dressupPoint !== 0) { + writer.uint32(232).uint32(message.dressupPoint); + } + if (message.stPlayCount !== 0) { + writer.uint32(272).uint32(message.stPlayCount); + } + if (message.stClearBits !== 0) { + writer.uint32(280).uint32(message.stClearBits); + } + if (message.stClearDivCount !== 0) { + writer.uint32(288).uint32(message.stClearDivCount); + } + if (message.stClearCount !== 0) { + writer.uint32(296).uint32(message.stClearCount); + } + if (message.stLoseBits !== 0) { + writer.uint32(304).uint64(message.stLoseBits); + } + if (message.stConsecutiveWins !== 0) { + writer.uint32(320).uint32(message.stConsecutiveWins); + } + if (message.stConsecutiveWinsMax !== 0) { + writer.uint32(328).uint32(message.stConsecutiveWinsMax); + } + if (message.stCompleted100Episodes === true) { + writer.uint32(504).bool(message.stCompleted100Episodes); + } + if (message.challenger !== undefined) { + ChallengerCar.encode( + message.challenger, + writer.uint32(338).fork() + ).ldelim(); + } + if (message.challengerReturnCount !== 0) { + writer.uint32(344).uint32(message.challengerReturnCount); + } + if (message.numOfChallengers !== 0) { + writer.uint32(440).uint32(message.numOfChallengers); + } + if (message.opponentGhost !== undefined) { + GhostCar.encode( + message.opponentGhost, + writer.uint32(354).fork() + ).ldelim(); + } + if (message.opponentTrailId !== 0) { + writer.uint32(360).uint64(message.opponentTrailId); + } + if (message.opponentCompetitionId !== 0) { + writer.uint32(368).uint32(message.opponentCompetitionId); + } + if (message.competitionParameter !== undefined) { + GhostCompetitionParameter.encode( + message.competitionParameter, + writer.uint32(378).fork() + ).ldelim(); + } + for (const v of message.specialTitles) { + writer.uint32(386).string(v!); + } + for (const v of message.earnedTitles) { + writer.uint32(394).string(v!); + } + for (const v of message.ownedItems) { + CarItem.encode(v!, writer.uint32(402).fork()).ldelim(); + } + if (message.auraMotifAutoChange === true) { + writer.uint32(408).bool(message.auraMotifAutoChange); + } + if (message.screenshotCount !== 0) { + writer.uint32(424).uint32(message.screenshotCount); + } + if (message.announceEventModePrize === true) { + writer.uint32(464).bool(message.announceEventModePrize); + } + if (message.transferred === true) { + writer.uint32(480).bool(message.transferred); + } + if (message.driveLastPlayedAt !== 0) { + writer.uint32(488).uint32(message.driveLastPlayedAt); + } + if (message.insurance !== undefined) { + LoadCarResponse_StoryInsurance.encode( + message.insurance, + writer.uint32(498).fork() + ).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): LoadCarResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadCarResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.car = Car.decode(reader, reader.uint32()); + break; + case 3: + message.tuningPoint = reader.uint32(); + break; + case 6: + message.odometer = reader.uint32(); + break; + case 7: + message.playCount = reader.uint32(); + break; + case 8: + message.earnedCustomColor = reader.bool(); + break; + case 10: + message.setting = CarSetting.decode(reader, reader.uint32()); + break; + case 12: + message.vsPlayCount = reader.uint32(); + break; + case 13: + message.vsBurstCount = reader.uint32(); + break; + case 14: + message.vsStarCount = reader.uint32(); + break; + case 15: + message.vsStarCountMax = reader.uint32(); + break; + case 16: + message.vsCoolOrWild = reader.sint32(); + break; + case 17: + message.vsSmoothOrRough = reader.sint32(); + break; + case 18: + message.vsTripleStarMedals = reader.uint32(); + break; + case 19: + message.vsDoubleStarMedals = reader.uint32(); + break; + case 20: + message.vsSingleStarMedals = reader.uint32(); + break; + case 21: + message.vsPlainMedals = reader.uint32(); + break; + case 22: + message.rgPlayCount = reader.uint32(); + break; + case 23: + message.rgWinCount = reader.uint32(); + break; + case 24: + message.rgTrophy = reader.uint32(); + break; + case 64: + message.rgPreviousVersionPlayCount = reader.uint32(); + break; + case 25: + message.rgScore = reader.uint32(); + break; + case 26: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.rgRegionMapScore.push(reader.uint32()); + } + } else { + message.rgRegionMapScore.push(reader.uint32()); + } + break; + case 30: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.rgRegions.push(reader.uint32()); + } + } else { + message.rgRegions.push(reader.uint32()); + } + break; + case 27: + message.rgStamp = reader.uint32(); + break; + case 59: + message.rgAcquireAllCrowns = reader.bool(); + break; + case 28: + message.dressupLevel = reader.uint32(); + break; + case 29: + message.dressupPoint = reader.uint32(); + break; + case 34: + message.stPlayCount = reader.uint32(); + break; + case 35: + message.stClearBits = reader.uint32(); + break; + case 36: + message.stClearDivCount = reader.uint32(); + break; + case 37: + message.stClearCount = reader.uint32(); + break; + case 38: + message.stLoseBits = longToNumber(reader.uint64() as Long); + break; + case 40: + message.stConsecutiveWins = reader.uint32(); + break; + case 41: + message.stConsecutiveWinsMax = reader.uint32(); + break; + case 63: + message.stCompleted100Episodes = reader.bool(); + break; + case 42: + message.challenger = ChallengerCar.decode(reader, reader.uint32()); + break; + case 43: + message.challengerReturnCount = reader.uint32(); + break; + case 55: + message.numOfChallengers = reader.uint32(); + break; + case 44: + message.opponentGhost = GhostCar.decode(reader, reader.uint32()); + break; + case 45: + message.opponentTrailId = longToNumber(reader.uint64() as Long); + break; + case 46: + message.opponentCompetitionId = reader.uint32(); + break; + case 47: + message.competitionParameter = GhostCompetitionParameter.decode( + reader, + reader.uint32() + ); + break; + case 48: + message.specialTitles.push(reader.string()); + break; + case 49: + message.earnedTitles.push(reader.string()); + break; + case 50: + message.ownedItems.push(CarItem.decode(reader, reader.uint32())); + break; + case 51: + message.auraMotifAutoChange = reader.bool(); + break; + case 53: + message.screenshotCount = reader.uint32(); + break; + case 58: + message.announceEventModePrize = reader.bool(); + break; + case 60: + message.transferred = reader.bool(); + break; + case 61: + message.driveLastPlayedAt = reader.uint32(); + break; + case 62: + message.insurance = LoadCarResponse_StoryInsurance.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadCarResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + tuningPoint: isSet(object.tuningPoint) ? Number(object.tuningPoint) : 0, + odometer: isSet(object.odometer) ? Number(object.odometer) : 0, + playCount: isSet(object.playCount) ? Number(object.playCount) : 0, + earnedCustomColor: isSet(object.earnedCustomColor) + ? Boolean(object.earnedCustomColor) + : false, + setting: isSet(object.setting) + ? CarSetting.fromJSON(object.setting) + : undefined, + vsPlayCount: isSet(object.vsPlayCount) ? Number(object.vsPlayCount) : 0, + vsBurstCount: isSet(object.vsBurstCount) + ? Number(object.vsBurstCount) + : 0, + vsStarCount: isSet(object.vsStarCount) ? Number(object.vsStarCount) : 0, + vsStarCountMax: isSet(object.vsStarCountMax) + ? Number(object.vsStarCountMax) + : 0, + vsCoolOrWild: isSet(object.vsCoolOrWild) + ? Number(object.vsCoolOrWild) + : 0, + vsSmoothOrRough: isSet(object.vsSmoothOrRough) + ? Number(object.vsSmoothOrRough) + : 0, + vsTripleStarMedals: isSet(object.vsTripleStarMedals) + ? Number(object.vsTripleStarMedals) + : 0, + vsDoubleStarMedals: isSet(object.vsDoubleStarMedals) + ? Number(object.vsDoubleStarMedals) + : 0, + vsSingleStarMedals: isSet(object.vsSingleStarMedals) + ? Number(object.vsSingleStarMedals) + : 0, + vsPlainMedals: isSet(object.vsPlainMedals) + ? Number(object.vsPlainMedals) + : 0, + rgPlayCount: isSet(object.rgPlayCount) ? Number(object.rgPlayCount) : 0, + rgWinCount: isSet(object.rgWinCount) ? Number(object.rgWinCount) : 0, + rgTrophy: isSet(object.rgTrophy) ? Number(object.rgTrophy) : 0, + rgPreviousVersionPlayCount: isSet(object.rgPreviousVersionPlayCount) + ? Number(object.rgPreviousVersionPlayCount) + : 0, + rgScore: isSet(object.rgScore) ? Number(object.rgScore) : 0, + rgRegionMapScore: Array.isArray(object?.rgRegionMapScore) + ? object.rgRegionMapScore.map((e: any) => Number(e)) + : [], + rgRegions: Array.isArray(object?.rgRegions) + ? object.rgRegions.map((e: any) => Number(e)) + : [], + rgStamp: isSet(object.rgStamp) ? Number(object.rgStamp) : 0, + rgAcquireAllCrowns: isSet(object.rgAcquireAllCrowns) + ? Boolean(object.rgAcquireAllCrowns) + : false, + dressupLevel: isSet(object.dressupLevel) + ? Number(object.dressupLevel) + : 0, + dressupPoint: isSet(object.dressupPoint) + ? Number(object.dressupPoint) + : 0, + stPlayCount: isSet(object.stPlayCount) ? Number(object.stPlayCount) : 0, + stClearBits: isSet(object.stClearBits) ? Number(object.stClearBits) : 0, + stClearDivCount: isSet(object.stClearDivCount) + ? Number(object.stClearDivCount) + : 0, + stClearCount: isSet(object.stClearCount) + ? Number(object.stClearCount) + : 0, + stLoseBits: isSet(object.stLoseBits) ? Number(object.stLoseBits) : 0, + stConsecutiveWins: isSet(object.stConsecutiveWins) + ? Number(object.stConsecutiveWins) + : 0, + stConsecutiveWinsMax: isSet(object.stConsecutiveWinsMax) + ? Number(object.stConsecutiveWinsMax) + : 0, + stCompleted100Episodes: isSet(object.stCompleted100Episodes) + ? Boolean(object.stCompleted100Episodes) + : false, + challenger: isSet(object.challenger) + ? ChallengerCar.fromJSON(object.challenger) + : undefined, + challengerReturnCount: isSet(object.challengerReturnCount) + ? Number(object.challengerReturnCount) + : 0, + numOfChallengers: isSet(object.numOfChallengers) + ? Number(object.numOfChallengers) + : 0, + opponentGhost: isSet(object.opponentGhost) + ? GhostCar.fromJSON(object.opponentGhost) + : undefined, + opponentTrailId: isSet(object.opponentTrailId) + ? Number(object.opponentTrailId) + : 0, + opponentCompetitionId: isSet(object.opponentCompetitionId) + ? Number(object.opponentCompetitionId) + : 0, + competitionParameter: isSet(object.competitionParameter) + ? GhostCompetitionParameter.fromJSON(object.competitionParameter) + : undefined, + specialTitles: Array.isArray(object?.specialTitles) + ? object.specialTitles.map((e: any) => String(e)) + : [], + earnedTitles: Array.isArray(object?.earnedTitles) + ? object.earnedTitles.map((e: any) => String(e)) + : [], + ownedItems: Array.isArray(object?.ownedItems) + ? object.ownedItems.map((e: any) => CarItem.fromJSON(e)) + : [], + auraMotifAutoChange: isSet(object.auraMotifAutoChange) + ? Boolean(object.auraMotifAutoChange) + : false, + screenshotCount: isSet(object.screenshotCount) + ? Number(object.screenshotCount) + : 0, + announceEventModePrize: isSet(object.announceEventModePrize) + ? Boolean(object.announceEventModePrize) + : false, + transferred: isSet(object.transferred) + ? Boolean(object.transferred) + : false, + driveLastPlayedAt: isSet(object.driveLastPlayedAt) + ? Number(object.driveLastPlayedAt) + : 0, + insurance: isSet(object.insurance) + ? LoadCarResponse_StoryInsurance.fromJSON(object.insurance) + : undefined, + }; + }, + + toJSON(message: LoadCarResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.tuningPoint !== undefined && + (obj.tuningPoint = Math.round(message.tuningPoint)); + message.odometer !== undefined && + (obj.odometer = Math.round(message.odometer)); + message.playCount !== undefined && + (obj.playCount = Math.round(message.playCount)); + message.earnedCustomColor !== undefined && + (obj.earnedCustomColor = message.earnedCustomColor); + message.setting !== undefined && + (obj.setting = message.setting + ? CarSetting.toJSON(message.setting) + : undefined); + message.vsPlayCount !== undefined && + (obj.vsPlayCount = Math.round(message.vsPlayCount)); + message.vsBurstCount !== undefined && + (obj.vsBurstCount = Math.round(message.vsBurstCount)); + message.vsStarCount !== undefined && + (obj.vsStarCount = Math.round(message.vsStarCount)); + message.vsStarCountMax !== undefined && + (obj.vsStarCountMax = Math.round(message.vsStarCountMax)); + message.vsCoolOrWild !== undefined && + (obj.vsCoolOrWild = Math.round(message.vsCoolOrWild)); + message.vsSmoothOrRough !== undefined && + (obj.vsSmoothOrRough = Math.round(message.vsSmoothOrRough)); + message.vsTripleStarMedals !== undefined && + (obj.vsTripleStarMedals = Math.round(message.vsTripleStarMedals)); + message.vsDoubleStarMedals !== undefined && + (obj.vsDoubleStarMedals = Math.round(message.vsDoubleStarMedals)); + message.vsSingleStarMedals !== undefined && + (obj.vsSingleStarMedals = Math.round(message.vsSingleStarMedals)); + message.vsPlainMedals !== undefined && + (obj.vsPlainMedals = Math.round(message.vsPlainMedals)); + message.rgPlayCount !== undefined && + (obj.rgPlayCount = Math.round(message.rgPlayCount)); + message.rgWinCount !== undefined && + (obj.rgWinCount = Math.round(message.rgWinCount)); + message.rgTrophy !== undefined && + (obj.rgTrophy = Math.round(message.rgTrophy)); + message.rgPreviousVersionPlayCount !== undefined && + (obj.rgPreviousVersionPlayCount = Math.round( + message.rgPreviousVersionPlayCount + )); + message.rgScore !== undefined && + (obj.rgScore = Math.round(message.rgScore)); + if (message.rgRegionMapScore) { + obj.rgRegionMapScore = message.rgRegionMapScore.map((e) => Math.round(e)); + } else { + obj.rgRegionMapScore = []; + } + if (message.rgRegions) { + obj.rgRegions = message.rgRegions.map((e) => Math.round(e)); + } else { + obj.rgRegions = []; + } + message.rgStamp !== undefined && + (obj.rgStamp = Math.round(message.rgStamp)); + message.rgAcquireAllCrowns !== undefined && + (obj.rgAcquireAllCrowns = message.rgAcquireAllCrowns); + message.dressupLevel !== undefined && + (obj.dressupLevel = Math.round(message.dressupLevel)); + message.dressupPoint !== undefined && + (obj.dressupPoint = Math.round(message.dressupPoint)); + message.stPlayCount !== undefined && + (obj.stPlayCount = Math.round(message.stPlayCount)); + message.stClearBits !== undefined && + (obj.stClearBits = Math.round(message.stClearBits)); + message.stClearDivCount !== undefined && + (obj.stClearDivCount = Math.round(message.stClearDivCount)); + message.stClearCount !== undefined && + (obj.stClearCount = Math.round(message.stClearCount)); + message.stLoseBits !== undefined && + (obj.stLoseBits = Math.round(message.stLoseBits)); + message.stConsecutiveWins !== undefined && + (obj.stConsecutiveWins = Math.round(message.stConsecutiveWins)); + message.stConsecutiveWinsMax !== undefined && + (obj.stConsecutiveWinsMax = Math.round(message.stConsecutiveWinsMax)); + message.stCompleted100Episodes !== undefined && + (obj.stCompleted100Episodes = message.stCompleted100Episodes); + message.challenger !== undefined && + (obj.challenger = message.challenger + ? ChallengerCar.toJSON(message.challenger) + : undefined); + message.challengerReturnCount !== undefined && + (obj.challengerReturnCount = Math.round(message.challengerReturnCount)); + message.numOfChallengers !== undefined && + (obj.numOfChallengers = Math.round(message.numOfChallengers)); + message.opponentGhost !== undefined && + (obj.opponentGhost = message.opponentGhost + ? GhostCar.toJSON(message.opponentGhost) + : undefined); + message.opponentTrailId !== undefined && + (obj.opponentTrailId = Math.round(message.opponentTrailId)); + message.opponentCompetitionId !== undefined && + (obj.opponentCompetitionId = Math.round(message.opponentCompetitionId)); + message.competitionParameter !== undefined && + (obj.competitionParameter = message.competitionParameter + ? GhostCompetitionParameter.toJSON(message.competitionParameter) + : undefined); + if (message.specialTitles) { + obj.specialTitles = message.specialTitles.map((e) => e); + } else { + obj.specialTitles = []; + } + if (message.earnedTitles) { + obj.earnedTitles = message.earnedTitles.map((e) => e); + } else { + obj.earnedTitles = []; + } + if (message.ownedItems) { + obj.ownedItems = message.ownedItems.map((e) => + e ? CarItem.toJSON(e) : undefined + ); + } else { + obj.ownedItems = []; + } + message.auraMotifAutoChange !== undefined && + (obj.auraMotifAutoChange = message.auraMotifAutoChange); + message.screenshotCount !== undefined && + (obj.screenshotCount = Math.round(message.screenshotCount)); + message.announceEventModePrize !== undefined && + (obj.announceEventModePrize = message.announceEventModePrize); + message.transferred !== undefined && + (obj.transferred = message.transferred); + message.driveLastPlayedAt !== undefined && + (obj.driveLastPlayedAt = Math.round(message.driveLastPlayedAt)); + message.insurance !== undefined && + (obj.insurance = message.insurance + ? LoadCarResponse_StoryInsurance.toJSON(message.insurance) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadCarResponse { + const message = createBaseLoadCarResponse(); + message.error = object.error ?? 0; + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.tuningPoint = object.tuningPoint ?? 0; + message.odometer = object.odometer ?? 0; + message.playCount = object.playCount ?? 0; + message.earnedCustomColor = object.earnedCustomColor ?? false; + message.setting = + object.setting !== undefined && object.setting !== null + ? CarSetting.fromPartial(object.setting) + : undefined; + message.vsPlayCount = object.vsPlayCount ?? 0; + message.vsBurstCount = object.vsBurstCount ?? 0; + message.vsStarCount = object.vsStarCount ?? 0; + message.vsStarCountMax = object.vsStarCountMax ?? 0; + message.vsCoolOrWild = object.vsCoolOrWild ?? 0; + message.vsSmoothOrRough = object.vsSmoothOrRough ?? 0; + message.vsTripleStarMedals = object.vsTripleStarMedals ?? 0; + message.vsDoubleStarMedals = object.vsDoubleStarMedals ?? 0; + message.vsSingleStarMedals = object.vsSingleStarMedals ?? 0; + message.vsPlainMedals = object.vsPlainMedals ?? 0; + message.rgPlayCount = object.rgPlayCount ?? 0; + message.rgWinCount = object.rgWinCount ?? 0; + message.rgTrophy = object.rgTrophy ?? 0; + message.rgPreviousVersionPlayCount = object.rgPreviousVersionPlayCount ?? 0; + message.rgScore = object.rgScore ?? 0; + message.rgRegionMapScore = object.rgRegionMapScore?.map((e) => e) || []; + message.rgRegions = object.rgRegions?.map((e) => e) || []; + message.rgStamp = object.rgStamp ?? 0; + message.rgAcquireAllCrowns = object.rgAcquireAllCrowns ?? false; + message.dressupLevel = object.dressupLevel ?? 0; + message.dressupPoint = object.dressupPoint ?? 0; + message.stPlayCount = object.stPlayCount ?? 0; + message.stClearBits = object.stClearBits ?? 0; + message.stClearDivCount = object.stClearDivCount ?? 0; + message.stClearCount = object.stClearCount ?? 0; + message.stLoseBits = object.stLoseBits ?? 0; + message.stConsecutiveWins = object.stConsecutiveWins ?? 0; + message.stConsecutiveWinsMax = object.stConsecutiveWinsMax ?? 0; + message.stCompleted100Episodes = object.stCompleted100Episodes ?? false; + message.challenger = + object.challenger !== undefined && object.challenger !== null + ? ChallengerCar.fromPartial(object.challenger) + : undefined; + message.challengerReturnCount = object.challengerReturnCount ?? 0; + message.numOfChallengers = object.numOfChallengers ?? 0; + message.opponentGhost = + object.opponentGhost !== undefined && object.opponentGhost !== null + ? GhostCar.fromPartial(object.opponentGhost) + : undefined; + message.opponentTrailId = object.opponentTrailId ?? 0; + message.opponentCompetitionId = object.opponentCompetitionId ?? 0; + message.competitionParameter = + object.competitionParameter !== undefined && + object.competitionParameter !== null + ? GhostCompetitionParameter.fromPartial(object.competitionParameter) + : undefined; + message.specialTitles = object.specialTitles?.map((e) => e) || []; + message.earnedTitles = object.earnedTitles?.map((e) => e) || []; + message.ownedItems = + object.ownedItems?.map((e) => CarItem.fromPartial(e)) || []; + message.auraMotifAutoChange = object.auraMotifAutoChange ?? false; + message.screenshotCount = object.screenshotCount ?? 0; + message.announceEventModePrize = object.announceEventModePrize ?? false; + message.transferred = object.transferred ?? false; + message.driveLastPlayedAt = object.driveLastPlayedAt ?? 0; + message.insurance = + object.insurance !== undefined && object.insurance !== null + ? LoadCarResponse_StoryInsurance.fromPartial(object.insurance) + : undefined; + return message; + }, +}; + +function createBaseLoadCarResponse_StoryInsurance(): LoadCarResponse_StoryInsurance { + return { numOfRemains: 0 }; +} + +export const LoadCarResponse_StoryInsurance = { + encode( + message: LoadCarResponse_StoryInsurance, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.numOfRemains !== 0) { + writer.uint32(8).uint32(message.numOfRemains); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadCarResponse_StoryInsurance { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadCarResponse_StoryInsurance(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.numOfRemains = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadCarResponse_StoryInsurance { + return { + numOfRemains: isSet(object.numOfRemains) + ? Number(object.numOfRemains) + : 0, + }; + }, + + toJSON(message: LoadCarResponse_StoryInsurance): unknown { + const obj: any = {}; + message.numOfRemains !== undefined && + (obj.numOfRemains = Math.round(message.numOfRemains)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadCarResponse_StoryInsurance { + const message = createBaseLoadCarResponse_StoryInsurance(); + message.numOfRemains = object.numOfRemains ?? 0; + return message; + }, +}; + +function createBaseCreateCarRequest(): CreateCarRequest { + return { + userId: 0, + banapassportAmId: 0, + cardChipId: "", + accessCode: "", + cardTypeCode: 0, + cardRegionCode: 0, + device: 0, + car: undefined, + transmission: false, + timestamp: 0, + userItemId: 0, + deletedCarId: 0, + }; +} + +export const CreateCarRequest = { + encode( + message: CreateCarRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + if (message.banapassportAmId !== 0) { + writer.uint32(16).uint32(message.banapassportAmId); + } + if (message.cardChipId !== "") { + writer.uint32(26).string(message.cardChipId); + } + if (message.accessCode !== "") { + writer.uint32(34).string(message.accessCode); + } + if (message.cardTypeCode !== 0) { + writer.uint32(40).uint32(message.cardTypeCode); + } + if (message.cardRegionCode !== 0) { + writer.uint32(48).uint32(message.cardRegionCode); + } + if (message.device !== 0) { + writer.uint32(56).int32(message.device); + } + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(66).fork()).ldelim(); + } + if (message.transmission === true) { + writer.uint32(72).bool(message.transmission); + } + if (message.timestamp !== 0) { + writer.uint32(88).uint32(message.timestamp); + } + if (message.userItemId !== 0) { + writer.uint32(96).uint32(message.userItemId); + } + if (message.deletedCarId !== 0) { + writer.uint32(104).uint32(message.deletedCarId); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CreateCarRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCreateCarRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.banapassportAmId = reader.uint32(); + break; + case 3: + message.cardChipId = reader.string(); + break; + case 4: + message.accessCode = reader.string(); + break; + case 5: + message.cardTypeCode = reader.uint32(); + break; + case 6: + message.cardRegionCode = reader.uint32(); + break; + case 7: + message.device = reader.int32() as any; + break; + case 8: + message.car = Car.decode(reader, reader.uint32()); + break; + case 9: + message.transmission = reader.bool(); + break; + case 11: + message.timestamp = reader.uint32(); + break; + case 12: + message.userItemId = reader.uint32(); + break; + case 13: + message.deletedCarId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CreateCarRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + banapassportAmId: isSet(object.banapassportAmId) + ? Number(object.banapassportAmId) + : 0, + cardChipId: isSet(object.cardChipId) ? String(object.cardChipId) : "", + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + cardTypeCode: isSet(object.cardTypeCode) + ? Number(object.cardTypeCode) + : 0, + cardRegionCode: isSet(object.cardRegionCode) + ? Number(object.cardRegionCode) + : 0, + device: isSet(object.device) ? deviceTypeFromJSON(object.device) : 0, + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + transmission: isSet(object.transmission) + ? Boolean(object.transmission) + : false, + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + userItemId: isSet(object.userItemId) ? Number(object.userItemId) : 0, + deletedCarId: isSet(object.deletedCarId) + ? Number(object.deletedCarId) + : 0, + }; + }, + + toJSON(message: CreateCarRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.banapassportAmId !== undefined && + (obj.banapassportAmId = Math.round(message.banapassportAmId)); + message.cardChipId !== undefined && (obj.cardChipId = message.cardChipId); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.cardTypeCode !== undefined && + (obj.cardTypeCode = Math.round(message.cardTypeCode)); + message.cardRegionCode !== undefined && + (obj.cardRegionCode = Math.round(message.cardRegionCode)); + message.device !== undefined && + (obj.device = deviceTypeToJSON(message.device)); + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.transmission !== undefined && + (obj.transmission = message.transmission); + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + message.userItemId !== undefined && + (obj.userItemId = Math.round(message.userItemId)); + message.deletedCarId !== undefined && + (obj.deletedCarId = Math.round(message.deletedCarId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CreateCarRequest { + const message = createBaseCreateCarRequest(); + message.userId = object.userId ?? 0; + message.banapassportAmId = object.banapassportAmId ?? 0; + message.cardChipId = object.cardChipId ?? ""; + message.accessCode = object.accessCode ?? ""; + message.cardTypeCode = object.cardTypeCode ?? 0; + message.cardRegionCode = object.cardRegionCode ?? 0; + message.device = object.device ?? 0; + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.transmission = object.transmission ?? false; + message.timestamp = object.timestamp ?? 0; + message.userItemId = object.userItemId ?? 0; + message.deletedCarId = object.deletedCarId ?? 0; + return message; + }, +}; + +function createBaseCreateCarResponse(): CreateCarResponse { + return { + error: 0, + accessCode: "", + banapassportAmId: 0, + mbid: 0, + userId: 0, + carId: 0, + stClearBits: 0, + stClearDivCount: 0, + stClearCount: 0, + stLoseBits: 0, + stConsecutiveWins: 0, + stConsecutiveWinsMax: 0, + fullTunedCarCouponUnreceivableAt: 0, + }; +} + +export const CreateCarResponse = { + encode( + message: CreateCarResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.accessCode !== "") { + writer.uint32(18).string(message.accessCode); + } + if (message.banapassportAmId !== 0) { + writer.uint32(24).uint32(message.banapassportAmId); + } + if (message.mbid !== 0) { + writer.uint32(32).uint32(message.mbid); + } + if (message.userId !== 0) { + writer.uint32(40).uint32(message.userId); + } + if (message.carId !== 0) { + writer.uint32(48).uint32(message.carId); + } + if (message.stClearBits !== 0) { + writer.uint32(64).uint32(message.stClearBits); + } + if (message.stClearDivCount !== 0) { + writer.uint32(72).uint32(message.stClearDivCount); + } + if (message.stClearCount !== 0) { + writer.uint32(80).uint32(message.stClearCount); + } + if (message.stLoseBits !== 0) { + writer.uint32(88).uint64(message.stLoseBits); + } + if (message.stConsecutiveWins !== 0) { + writer.uint32(104).uint32(message.stConsecutiveWins); + } + if (message.stConsecutiveWinsMax !== 0) { + writer.uint32(112).uint32(message.stConsecutiveWinsMax); + } + if (message.fullTunedCarCouponUnreceivableAt !== 0) { + writer.uint32(136).uint32(message.fullTunedCarCouponUnreceivableAt); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CreateCarResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCreateCarResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.accessCode = reader.string(); + break; + case 3: + message.banapassportAmId = reader.uint32(); + break; + case 4: + message.mbid = reader.uint32(); + break; + case 5: + message.userId = reader.uint32(); + break; + case 6: + message.carId = reader.uint32(); + break; + case 8: + message.stClearBits = reader.uint32(); + break; + case 9: + message.stClearDivCount = reader.uint32(); + break; + case 10: + message.stClearCount = reader.uint32(); + break; + case 11: + message.stLoseBits = longToNumber(reader.uint64() as Long); + break; + case 13: + message.stConsecutiveWins = reader.uint32(); + break; + case 14: + message.stConsecutiveWinsMax = reader.uint32(); + break; + case 17: + message.fullTunedCarCouponUnreceivableAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CreateCarResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + banapassportAmId: isSet(object.banapassportAmId) + ? Number(object.banapassportAmId) + : 0, + mbid: isSet(object.mbid) ? Number(object.mbid) : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + carId: isSet(object.carId) ? Number(object.carId) : 0, + stClearBits: isSet(object.stClearBits) ? Number(object.stClearBits) : 0, + stClearDivCount: isSet(object.stClearDivCount) + ? Number(object.stClearDivCount) + : 0, + stClearCount: isSet(object.stClearCount) + ? Number(object.stClearCount) + : 0, + stLoseBits: isSet(object.stLoseBits) ? Number(object.stLoseBits) : 0, + stConsecutiveWins: isSet(object.stConsecutiveWins) + ? Number(object.stConsecutiveWins) + : 0, + stConsecutiveWinsMax: isSet(object.stConsecutiveWinsMax) + ? Number(object.stConsecutiveWinsMax) + : 0, + fullTunedCarCouponUnreceivableAt: isSet( + object.fullTunedCarCouponUnreceivableAt + ) + ? Number(object.fullTunedCarCouponUnreceivableAt) + : 0, + }; + }, + + toJSON(message: CreateCarResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.banapassportAmId !== undefined && + (obj.banapassportAmId = Math.round(message.banapassportAmId)); + message.mbid !== undefined && (obj.mbid = Math.round(message.mbid)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.stClearBits !== undefined && + (obj.stClearBits = Math.round(message.stClearBits)); + message.stClearDivCount !== undefined && + (obj.stClearDivCount = Math.round(message.stClearDivCount)); + message.stClearCount !== undefined && + (obj.stClearCount = Math.round(message.stClearCount)); + message.stLoseBits !== undefined && + (obj.stLoseBits = Math.round(message.stLoseBits)); + message.stConsecutiveWins !== undefined && + (obj.stConsecutiveWins = Math.round(message.stConsecutiveWins)); + message.stConsecutiveWinsMax !== undefined && + (obj.stConsecutiveWinsMax = Math.round(message.stConsecutiveWinsMax)); + message.fullTunedCarCouponUnreceivableAt !== undefined && + (obj.fullTunedCarCouponUnreceivableAt = Math.round( + message.fullTunedCarCouponUnreceivableAt + )); + return obj; + }, + + fromPartial, I>>( + object: I + ): CreateCarResponse { + const message = createBaseCreateCarResponse(); + message.error = object.error ?? 0; + message.accessCode = object.accessCode ?? ""; + message.banapassportAmId = object.banapassportAmId ?? 0; + message.mbid = object.mbid ?? 0; + message.userId = object.userId ?? 0; + message.carId = object.carId ?? 0; + message.stClearBits = object.stClearBits ?? 0; + message.stClearDivCount = object.stClearDivCount ?? 0; + message.stClearCount = object.stClearCount ?? 0; + message.stLoseBits = object.stLoseBits ?? 0; + message.stConsecutiveWins = object.stConsecutiveWins ?? 0; + message.stConsecutiveWinsMax = object.stConsecutiveWinsMax ?? 0; + message.fullTunedCarCouponUnreceivableAt = + object.fullTunedCarCouponUnreceivableAt ?? 0; + return message; + }, +}; + +function createBaseLoadGameHistoryRequest(): LoadGameHistoryRequest { + return { carId: 0 }; +} + +export const LoadGameHistoryRequest = { + encode( + message: LoadGameHistoryRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGameHistoryRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGameHistoryRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGameHistoryRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + }; + }, + + toJSON(message: LoadGameHistoryRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGameHistoryRequest { + const message = createBaseLoadGameHistoryRequest(); + message.carId = object.carId ?? 0; + return message; + }, +}; + +function createBaseLoadGameHistoryResponse(): LoadGameHistoryResponse { + return { + error: 0, + taRecords: [], + taRankingUpdatedAt: 0, + ghostHistory: [], + ghostBattleCount: 0, + ghostBattleWinCount: 0, + stampSheetCount: 0, + stampSheet: [], + }; +} + +export const LoadGameHistoryResponse = { + encode( + message: LoadGameHistoryResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.taRecords) { + LoadGameHistoryResponse_TimeAttackRecord.encode( + v!, + writer.uint32(18).fork() + ).ldelim(); + } + if (message.taRankingUpdatedAt !== 0) { + writer.uint32(24).uint32(message.taRankingUpdatedAt); + } + for (const v of message.ghostHistory) { + LoadGameHistoryResponse_GhostBattleRecord.encode( + v!, + writer.uint32(34).fork() + ).ldelim(); + } + if (message.ghostBattleCount !== 0) { + writer.uint32(40).uint32(message.ghostBattleCount); + } + if (message.ghostBattleWinCount !== 0) { + writer.uint32(48).uint32(message.ghostBattleWinCount); + } + if (message.stampSheetCount !== 0) { + writer.uint32(56).uint32(message.stampSheetCount); + } + writer.uint32(66).fork(); + for (const v of message.stampSheet) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGameHistoryResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGameHistoryResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.taRecords.push( + LoadGameHistoryResponse_TimeAttackRecord.decode( + reader, + reader.uint32() + ) + ); + break; + case 3: + message.taRankingUpdatedAt = reader.uint32(); + break; + case 4: + message.ghostHistory.push( + LoadGameHistoryResponse_GhostBattleRecord.decode( + reader, + reader.uint32() + ) + ); + break; + case 5: + message.ghostBattleCount = reader.uint32(); + break; + case 6: + message.ghostBattleWinCount = reader.uint32(); + break; + case 7: + message.stampSheetCount = reader.uint32(); + break; + case 8: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.stampSheet.push(reader.uint32()); + } + } else { + message.stampSheet.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGameHistoryResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + taRecords: Array.isArray(object?.taRecords) + ? object.taRecords.map((e: any) => + LoadGameHistoryResponse_TimeAttackRecord.fromJSON(e) + ) + : [], + taRankingUpdatedAt: isSet(object.taRankingUpdatedAt) + ? Number(object.taRankingUpdatedAt) + : 0, + ghostHistory: Array.isArray(object?.ghostHistory) + ? object.ghostHistory.map((e: any) => + LoadGameHistoryResponse_GhostBattleRecord.fromJSON(e) + ) + : [], + ghostBattleCount: isSet(object.ghostBattleCount) + ? Number(object.ghostBattleCount) + : 0, + ghostBattleWinCount: isSet(object.ghostBattleWinCount) + ? Number(object.ghostBattleWinCount) + : 0, + stampSheetCount: isSet(object.stampSheetCount) + ? Number(object.stampSheetCount) + : 0, + stampSheet: Array.isArray(object?.stampSheet) + ? object.stampSheet.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: LoadGameHistoryResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.taRecords) { + obj.taRecords = message.taRecords.map((e) => + e ? LoadGameHistoryResponse_TimeAttackRecord.toJSON(e) : undefined + ); + } else { + obj.taRecords = []; + } + message.taRankingUpdatedAt !== undefined && + (obj.taRankingUpdatedAt = Math.round(message.taRankingUpdatedAt)); + if (message.ghostHistory) { + obj.ghostHistory = message.ghostHistory.map((e) => + e ? LoadGameHistoryResponse_GhostBattleRecord.toJSON(e) : undefined + ); + } else { + obj.ghostHistory = []; + } + message.ghostBattleCount !== undefined && + (obj.ghostBattleCount = Math.round(message.ghostBattleCount)); + message.ghostBattleWinCount !== undefined && + (obj.ghostBattleWinCount = Math.round(message.ghostBattleWinCount)); + message.stampSheetCount !== undefined && + (obj.stampSheetCount = Math.round(message.stampSheetCount)); + if (message.stampSheet) { + obj.stampSheet = message.stampSheet.map((e) => Math.round(e)); + } else { + obj.stampSheet = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGameHistoryResponse { + const message = createBaseLoadGameHistoryResponse(); + message.error = object.error ?? 0; + message.taRecords = + object.taRecords?.map((e) => + LoadGameHistoryResponse_TimeAttackRecord.fromPartial(e) + ) || []; + message.taRankingUpdatedAt = object.taRankingUpdatedAt ?? 0; + message.ghostHistory = + object.ghostHistory?.map((e) => + LoadGameHistoryResponse_GhostBattleRecord.fromPartial(e) + ) || []; + message.ghostBattleCount = object.ghostBattleCount ?? 0; + message.ghostBattleWinCount = object.ghostBattleWinCount ?? 0; + message.stampSheetCount = object.stampSheetCount ?? 0; + message.stampSheet = object.stampSheet?.map((e) => e) || []; + return message; + }, +}; + +function createBaseLoadGameHistoryResponse_TimeAttackRecord(): LoadGameHistoryResponse_TimeAttackRecord { + return { + course: 0, + time: 0, + tunePower: 0, + tuneHandling: 0, + wholeRank: 0, + wholeParticipants: 0, + modelRank: 0, + modelParticipants: 0, + }; +} + +export const LoadGameHistoryResponse_TimeAttackRecord = { + encode( + message: LoadGameHistoryResponse_TimeAttackRecord, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.course !== 0) { + writer.uint32(8).uint32(message.course); + } + if (message.time !== 0) { + writer.uint32(16).uint32(message.time); + } + if (message.tunePower !== 0) { + writer.uint32(24).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(32).uint32(message.tuneHandling); + } + if (message.wholeRank !== 0) { + writer.uint32(40).uint32(message.wholeRank); + } + if (message.wholeParticipants !== 0) { + writer.uint32(48).uint32(message.wholeParticipants); + } + if (message.modelRank !== 0) { + writer.uint32(56).uint32(message.modelRank); + } + if (message.modelParticipants !== 0) { + writer.uint32(64).uint32(message.modelParticipants); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGameHistoryResponse_TimeAttackRecord { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGameHistoryResponse_TimeAttackRecord(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.course = reader.uint32(); + break; + case 2: + message.time = reader.uint32(); + break; + case 3: + message.tunePower = reader.uint32(); + break; + case 4: + message.tuneHandling = reader.uint32(); + break; + case 5: + message.wholeRank = reader.uint32(); + break; + case 6: + message.wholeParticipants = reader.uint32(); + break; + case 7: + message.modelRank = reader.uint32(); + break; + case 8: + message.modelParticipants = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGameHistoryResponse_TimeAttackRecord { + return { + course: isSet(object.course) ? Number(object.course) : 0, + time: isSet(object.time) ? Number(object.time) : 0, + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + wholeRank: isSet(object.wholeRank) ? Number(object.wholeRank) : 0, + wholeParticipants: isSet(object.wholeParticipants) + ? Number(object.wholeParticipants) + : 0, + modelRank: isSet(object.modelRank) ? Number(object.modelRank) : 0, + modelParticipants: isSet(object.modelParticipants) + ? Number(object.modelParticipants) + : 0, + }; + }, + + toJSON(message: LoadGameHistoryResponse_TimeAttackRecord): unknown { + const obj: any = {}; + message.course !== undefined && (obj.course = Math.round(message.course)); + message.time !== undefined && (obj.time = Math.round(message.time)); + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.wholeRank !== undefined && + (obj.wholeRank = Math.round(message.wholeRank)); + message.wholeParticipants !== undefined && + (obj.wholeParticipants = Math.round(message.wholeParticipants)); + message.modelRank !== undefined && + (obj.modelRank = Math.round(message.modelRank)); + message.modelParticipants !== undefined && + (obj.modelParticipants = Math.round(message.modelParticipants)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGameHistoryResponse_TimeAttackRecord { + const message = createBaseLoadGameHistoryResponse_TimeAttackRecord(); + message.course = object.course ?? 0; + message.time = object.time ?? 0; + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.wholeRank = object.wholeRank ?? 0; + message.wholeParticipants = object.wholeParticipants ?? 0; + message.modelRank = object.modelRank ?? 0; + message.modelParticipants = object.modelParticipants ?? 0; + return message; + }, +}; + +function createBaseLoadGameHistoryResponse_GhostBattleRecord(): LoadGameHistoryResponse_GhostBattleRecord { + return { + carSetting: undefined, + opponent: undefined, + mobs: [], + area: 0, + playedAt: 0, + playedShopName: "", + }; +} + +export const LoadGameHistoryResponse_GhostBattleRecord = { + encode( + message: LoadGameHistoryResponse_GhostBattleRecord, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carSetting !== undefined) { + LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting.encode( + message.carSetting, + writer.uint32(10).fork() + ).ldelim(); + } + if (message.opponent !== undefined) { + LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.encode( + message.opponent, + writer.uint32(18).fork() + ).ldelim(); + } + for (const v of message.mobs) { + LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.encode( + v!, + writer.uint32(26).fork() + ).ldelim(); + } + if (message.area !== 0) { + writer.uint32(32).uint32(message.area); + } + if (message.playedAt !== 0) { + writer.uint32(40).uint32(message.playedAt); + } + if (message.playedShopName !== "") { + writer.uint32(50).string(message.playedShopName); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGameHistoryResponse_GhostBattleRecord { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGameHistoryResponse_GhostBattleRecord(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carSetting = + LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting.decode( + reader, + reader.uint32() + ); + break; + case 2: + message.opponent = + LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.decode( + reader, + reader.uint32() + ); + break; + case 3: + message.mobs.push( + LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.decode( + reader, + reader.uint32() + ) + ); + break; + case 4: + message.area = reader.uint32(); + break; + case 5: + message.playedAt = reader.uint32(); + break; + case 6: + message.playedShopName = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGameHistoryResponse_GhostBattleRecord { + return { + carSetting: isSet(object.carSetting) + ? LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting.fromJSON( + object.carSetting + ) + : undefined, + opponent: isSet(object.opponent) + ? LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.fromJSON( + object.opponent + ) + : undefined, + mobs: Array.isArray(object?.mobs) + ? object.mobs.map((e: any) => + LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.fromJSON( + e + ) + ) + : [], + area: isSet(object.area) ? Number(object.area) : 0, + playedAt: isSet(object.playedAt) ? Number(object.playedAt) : 0, + playedShopName: isSet(object.playedShopName) + ? String(object.playedShopName) + : "", + }; + }, + + toJSON(message: LoadGameHistoryResponse_GhostBattleRecord): unknown { + const obj: any = {}; + message.carSetting !== undefined && + (obj.carSetting = message.carSetting + ? LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting.toJSON( + message.carSetting + ) + : undefined); + message.opponent !== undefined && + (obj.opponent = message.opponent + ? LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.toJSON( + message.opponent + ) + : undefined); + if (message.mobs) { + obj.mobs = message.mobs.map((e) => + e + ? LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.toJSON( + e + ) + : undefined + ); + } else { + obj.mobs = []; + } + message.area !== undefined && (obj.area = Math.round(message.area)); + message.playedAt !== undefined && + (obj.playedAt = Math.round(message.playedAt)); + message.playedShopName !== undefined && + (obj.playedShopName = message.playedShopName); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGameHistoryResponse_GhostBattleRecord { + const message = createBaseLoadGameHistoryResponse_GhostBattleRecord(); + message.carSetting = + object.carSetting !== undefined && object.carSetting !== null + ? LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting.fromPartial( + object.carSetting + ) + : undefined; + message.opponent = + object.opponent !== undefined && object.opponent !== null + ? LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.fromPartial( + object.opponent + ) + : undefined; + message.mobs = + object.mobs?.map((e) => + LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar.fromPartial( + e + ) + ) || []; + message.area = object.area ?? 0; + message.playedAt = object.playedAt ?? 0; + message.playedShopName = object.playedShopName ?? ""; + return message; + }, +}; + +function createBaseLoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting(): LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting { + return { tunePower: 0, tuneHandling: 0 }; +} + +export const LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting = { + encode( + message: LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = + createBaseLoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON( + object: any + ): LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + }; + }, + + toJSON( + message: LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting + ): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): LoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting { + const message = + createBaseLoadGameHistoryResponse_GhostBattleRecord_GhostCarSetting(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + return message; + }, +}; + +function createBaseLoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar(): LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar { + return { car: undefined, result: 0 }; +} + +export const LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar = { + encode( + message: LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.result !== 0) { + writer.uint32(16).int32(message.result); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = + createBaseLoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.result = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON( + object: any + ): LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + result: isSet(object.result) ? Number(object.result) : 0, + }; + }, + + toJSON( + message: LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar + ): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.result !== undefined && (obj.result = Math.round(message.result)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): LoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar { + const message = + createBaseLoadGameHistoryResponse_GhostBattleRecord_GhostBattleRecordCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.result = object.result ?? 0; + return message; + }, +}; + +function createBaseUpdateCarRequest(): UpdateCarRequest { + return { + carId: 0, + car: undefined, + earnedItems: [], + setting: undefined, + toBeDeleted: false, + auraMotifAutoChange: false, + rgStamp: 0, + timestamp: 0, + }; +} + +export const UpdateCarRequest = { + encode( + message: UpdateCarRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(18).fork()).ldelim(); + } + for (const v of message.earnedItems) { + CarItem.encode(v!, writer.uint32(34).fork()).ldelim(); + } + if (message.setting !== undefined) { + CarSetting.encode(message.setting, writer.uint32(42).fork()).ldelim(); + } + if (message.toBeDeleted === true) { + writer.uint32(72).bool(message.toBeDeleted); + } + if (message.auraMotifAutoChange === true) { + writer.uint32(80).bool(message.auraMotifAutoChange); + } + if (message.rgStamp !== 0) { + writer.uint32(96).uint32(message.rgStamp); + } + if (message.timestamp !== 0) { + writer.uint32(104).uint32(message.timestamp); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): UpdateCarRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateCarRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.car = Car.decode(reader, reader.uint32()); + break; + case 4: + message.earnedItems.push(CarItem.decode(reader, reader.uint32())); + break; + case 5: + message.setting = CarSetting.decode(reader, reader.uint32()); + break; + case 9: + message.toBeDeleted = reader.bool(); + break; + case 10: + message.auraMotifAutoChange = reader.bool(); + break; + case 12: + message.rgStamp = reader.uint32(); + break; + case 13: + message.timestamp = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpdateCarRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + earnedItems: Array.isArray(object?.earnedItems) + ? object.earnedItems.map((e: any) => CarItem.fromJSON(e)) + : [], + setting: isSet(object.setting) + ? CarSetting.fromJSON(object.setting) + : undefined, + toBeDeleted: isSet(object.toBeDeleted) + ? Boolean(object.toBeDeleted) + : false, + auraMotifAutoChange: isSet(object.auraMotifAutoChange) + ? Boolean(object.auraMotifAutoChange) + : false, + rgStamp: isSet(object.rgStamp) ? Number(object.rgStamp) : 0, + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + }; + }, + + toJSON(message: UpdateCarRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + if (message.earnedItems) { + obj.earnedItems = message.earnedItems.map((e) => + e ? CarItem.toJSON(e) : undefined + ); + } else { + obj.earnedItems = []; + } + message.setting !== undefined && + (obj.setting = message.setting + ? CarSetting.toJSON(message.setting) + : undefined); + message.toBeDeleted !== undefined && + (obj.toBeDeleted = message.toBeDeleted); + message.auraMotifAutoChange !== undefined && + (obj.auraMotifAutoChange = message.auraMotifAutoChange); + message.rgStamp !== undefined && + (obj.rgStamp = Math.round(message.rgStamp)); + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + return obj; + }, + + fromPartial, I>>( + object: I + ): UpdateCarRequest { + const message = createBaseUpdateCarRequest(); + message.carId = object.carId ?? 0; + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.earnedItems = + object.earnedItems?.map((e) => CarItem.fromPartial(e)) || []; + message.setting = + object.setting !== undefined && object.setting !== null + ? CarSetting.fromPartial(object.setting) + : undefined; + message.toBeDeleted = object.toBeDeleted ?? false; + message.auraMotifAutoChange = object.auraMotifAutoChange ?? false; + message.rgStamp = object.rgStamp ?? 0; + message.timestamp = object.timestamp ?? 0; + return message; + }, +}; + +function createBaseUpdateCarResponse(): UpdateCarResponse { + return { error: 0 }; +} + +export const UpdateCarResponse = { + encode( + message: UpdateCarResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): UpdateCarResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateCarResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpdateCarResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: UpdateCarResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): UpdateCarResponse { + const message = createBaseUpdateCarResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseSaveGameResultRequest(): SaveGameResultRequest { + return { + carId: 0, + gameMode: 1, + playedAt: 0, + playCount: 0, + retired: false, + timeup: false, + car: undefined, + setting: undefined, + odometer: 0, + earnedCustomColor: false, + confirmedTutorials: [], + earnedItems: [], + earnedUserItems: [], + preservedTitles: [], + neighborCars: [], + stResult: undefined, + taResult: undefined, + vsResult: undefined, + rgResult: undefined, + }; +} + +export const SaveGameResultRequest = { + encode( + message: SaveGameResultRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.gameMode !== 1) { + writer.uint32(16).int32(message.gameMode); + } + if (message.playedAt !== 0) { + writer.uint32(24).uint32(message.playedAt); + } + if (message.playCount !== 0) { + writer.uint32(32).uint32(message.playCount); + } + if (message.retired === true) { + writer.uint32(40).bool(message.retired); + } + if (message.timeup === true) { + writer.uint32(48).bool(message.timeup); + } + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(58).fork()).ldelim(); + } + if (message.setting !== undefined) { + CarSetting.encode(message.setting, writer.uint32(66).fork()).ldelim(); + } + if (message.odometer !== 0) { + writer.uint32(72).uint32(message.odometer); + } + if (message.earnedCustomColor === true) { + writer.uint32(88).bool(message.earnedCustomColor); + } + writer.uint32(98).fork(); + for (const v of message.confirmedTutorials) { + writer.int32(v); + } + writer.ldelim(); + for (const v of message.earnedItems) { + CarItem.encode(v!, writer.uint32(106).fork()).ldelim(); + } + for (const v of message.earnedUserItems) { + UserItem.encode(v!, writer.uint32(114).fork()).ldelim(); + } + for (const v of message.preservedTitles) { + writer.uint32(122).string(v!); + } + writer.uint32(170).fork(); + for (const v of message.neighborCars) { + writer.uint32(v); + } + writer.ldelim(); + if (message.stResult !== undefined) { + SaveGameResultRequest_StoryResult.encode( + message.stResult, + writer.uint32(178).fork() + ).ldelim(); + } + if (message.taResult !== undefined) { + SaveGameResultRequest_TimeAttackResult.encode( + message.taResult, + writer.uint32(186).fork() + ).ldelim(); + } + if (message.vsResult !== undefined) { + SaveGameResultRequest_VersusBattleResult.encode( + message.vsResult, + writer.uint32(194).fork() + ).ldelim(); + } + if (message.rgResult !== undefined) { + SaveGameResultRequest_GhostBattleResult.encode( + message.rgResult, + writer.uint32(202).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveGameResultRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.gameMode = reader.int32() as any; + break; + case 3: + message.playedAt = reader.uint32(); + break; + case 4: + message.playCount = reader.uint32(); + break; + case 5: + message.retired = reader.bool(); + break; + case 6: + message.timeup = reader.bool(); + break; + case 7: + message.car = Car.decode(reader, reader.uint32()); + break; + case 8: + message.setting = CarSetting.decode(reader, reader.uint32()); + break; + case 9: + message.odometer = reader.uint32(); + break; + case 11: + message.earnedCustomColor = reader.bool(); + break; + case 12: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.confirmedTutorials.push(reader.int32() as any); + } + } else { + message.confirmedTutorials.push(reader.int32() as any); + } + break; + case 13: + message.earnedItems.push(CarItem.decode(reader, reader.uint32())); + break; + case 14: + message.earnedUserItems.push( + UserItem.decode(reader, reader.uint32()) + ); + break; + case 15: + message.preservedTitles.push(reader.string()); + break; + case 21: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.neighborCars.push(reader.uint32()); + } + } else { + message.neighborCars.push(reader.uint32()); + } + break; + case 22: + message.stResult = SaveGameResultRequest_StoryResult.decode( + reader, + reader.uint32() + ); + break; + case 23: + message.taResult = SaveGameResultRequest_TimeAttackResult.decode( + reader, + reader.uint32() + ); + break; + case 24: + message.vsResult = SaveGameResultRequest_VersusBattleResult.decode( + reader, + reader.uint32() + ); + break; + case 25: + message.rgResult = SaveGameResultRequest_GhostBattleResult.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveGameResultRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + gameMode: isSet(object.gameMode) ? gameModeFromJSON(object.gameMode) : 1, + playedAt: isSet(object.playedAt) ? Number(object.playedAt) : 0, + playCount: isSet(object.playCount) ? Number(object.playCount) : 0, + retired: isSet(object.retired) ? Boolean(object.retired) : false, + timeup: isSet(object.timeup) ? Boolean(object.timeup) : false, + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + setting: isSet(object.setting) + ? CarSetting.fromJSON(object.setting) + : undefined, + odometer: isSet(object.odometer) ? Number(object.odometer) : 0, + earnedCustomColor: isSet(object.earnedCustomColor) + ? Boolean(object.earnedCustomColor) + : false, + confirmedTutorials: Array.isArray(object?.confirmedTutorials) + ? object.confirmedTutorials.map((e: any) => tutorialTypeFromJSON(e)) + : [], + earnedItems: Array.isArray(object?.earnedItems) + ? object.earnedItems.map((e: any) => CarItem.fromJSON(e)) + : [], + earnedUserItems: Array.isArray(object?.earnedUserItems) + ? object.earnedUserItems.map((e: any) => UserItem.fromJSON(e)) + : [], + preservedTitles: Array.isArray(object?.preservedTitles) + ? object.preservedTitles.map((e: any) => String(e)) + : [], + neighborCars: Array.isArray(object?.neighborCars) + ? object.neighborCars.map((e: any) => Number(e)) + : [], + stResult: isSet(object.stResult) + ? SaveGameResultRequest_StoryResult.fromJSON(object.stResult) + : undefined, + taResult: isSet(object.taResult) + ? SaveGameResultRequest_TimeAttackResult.fromJSON(object.taResult) + : undefined, + vsResult: isSet(object.vsResult) + ? SaveGameResultRequest_VersusBattleResult.fromJSON(object.vsResult) + : undefined, + rgResult: isSet(object.rgResult) + ? SaveGameResultRequest_GhostBattleResult.fromJSON(object.rgResult) + : undefined, + }; + }, + + toJSON(message: SaveGameResultRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.gameMode !== undefined && + (obj.gameMode = gameModeToJSON(message.gameMode)); + message.playedAt !== undefined && + (obj.playedAt = Math.round(message.playedAt)); + message.playCount !== undefined && + (obj.playCount = Math.round(message.playCount)); + message.retired !== undefined && (obj.retired = message.retired); + message.timeup !== undefined && (obj.timeup = message.timeup); + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.setting !== undefined && + (obj.setting = message.setting + ? CarSetting.toJSON(message.setting) + : undefined); + message.odometer !== undefined && + (obj.odometer = Math.round(message.odometer)); + message.earnedCustomColor !== undefined && + (obj.earnedCustomColor = message.earnedCustomColor); + if (message.confirmedTutorials) { + obj.confirmedTutorials = message.confirmedTutorials.map((e) => + tutorialTypeToJSON(e) + ); + } else { + obj.confirmedTutorials = []; + } + if (message.earnedItems) { + obj.earnedItems = message.earnedItems.map((e) => + e ? CarItem.toJSON(e) : undefined + ); + } else { + obj.earnedItems = []; + } + if (message.earnedUserItems) { + obj.earnedUserItems = message.earnedUserItems.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.earnedUserItems = []; + } + if (message.preservedTitles) { + obj.preservedTitles = message.preservedTitles.map((e) => e); + } else { + obj.preservedTitles = []; + } + if (message.neighborCars) { + obj.neighborCars = message.neighborCars.map((e) => Math.round(e)); + } else { + obj.neighborCars = []; + } + message.stResult !== undefined && + (obj.stResult = message.stResult + ? SaveGameResultRequest_StoryResult.toJSON(message.stResult) + : undefined); + message.taResult !== undefined && + (obj.taResult = message.taResult + ? SaveGameResultRequest_TimeAttackResult.toJSON(message.taResult) + : undefined); + message.vsResult !== undefined && + (obj.vsResult = message.vsResult + ? SaveGameResultRequest_VersusBattleResult.toJSON(message.vsResult) + : undefined); + message.rgResult !== undefined && + (obj.rgResult = message.rgResult + ? SaveGameResultRequest_GhostBattleResult.toJSON(message.rgResult) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveGameResultRequest { + const message = createBaseSaveGameResultRequest(); + message.carId = object.carId ?? 0; + message.gameMode = object.gameMode ?? 1; + message.playedAt = object.playedAt ?? 0; + message.playCount = object.playCount ?? 0; + message.retired = object.retired ?? false; + message.timeup = object.timeup ?? false; + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.setting = + object.setting !== undefined && object.setting !== null + ? CarSetting.fromPartial(object.setting) + : undefined; + message.odometer = object.odometer ?? 0; + message.earnedCustomColor = object.earnedCustomColor ?? false; + message.confirmedTutorials = object.confirmedTutorials?.map((e) => e) || []; + message.earnedItems = + object.earnedItems?.map((e) => CarItem.fromPartial(e)) || []; + message.earnedUserItems = + object.earnedUserItems?.map((e) => UserItem.fromPartial(e)) || []; + message.preservedTitles = object.preservedTitles?.map((e) => e) || []; + message.neighborCars = object.neighborCars?.map((e) => e) || []; + message.stResult = + object.stResult !== undefined && object.stResult !== null + ? SaveGameResultRequest_StoryResult.fromPartial(object.stResult) + : undefined; + message.taResult = + object.taResult !== undefined && object.taResult !== null + ? SaveGameResultRequest_TimeAttackResult.fromPartial(object.taResult) + : undefined; + message.vsResult = + object.vsResult !== undefined && object.vsResult !== null + ? SaveGameResultRequest_VersusBattleResult.fromPartial(object.vsResult) + : undefined; + message.rgResult = + object.rgResult !== undefined && object.rgResult !== null + ? SaveGameResultRequest_GhostBattleResult.fromPartial(object.rgResult) + : undefined; + return message; + }, +}; + +function createBaseSaveGameResultRequest_StoryResult(): SaveGameResultRequest_StoryResult { + return { + stPlayCount: 0, + stPlayedStory: 0, + tuningPoint: 0, + stClearBits: 0, + stClearDivCount: 0, + stClearCount: 0, + stLoseBits: 0, + stConsecutiveWins: 0, + stCompleted100Episodes: false, + isInsuranceUsed: false, + }; +} + +export const SaveGameResultRequest_StoryResult = { + encode( + message: SaveGameResultRequest_StoryResult, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.stPlayCount !== 0) { + writer.uint32(8).uint32(message.stPlayCount); + } + if (message.stPlayedStory !== 0) { + writer.uint32(72).uint32(message.stPlayedStory); + } + if (message.tuningPoint !== 0) { + writer.uint32(16).uint32(message.tuningPoint); + } + if (message.stClearBits !== 0) { + writer.uint32(24).uint32(message.stClearBits); + } + if (message.stClearDivCount !== 0) { + writer.uint32(32).uint32(message.stClearDivCount); + } + if (message.stClearCount !== 0) { + writer.uint32(40).uint32(message.stClearCount); + } + if (message.stLoseBits !== 0) { + writer.uint32(48).uint64(message.stLoseBits); + } + if (message.stConsecutiveWins !== 0) { + writer.uint32(64).uint32(message.stConsecutiveWins); + } + if (message.stCompleted100Episodes === true) { + writer.uint32(80).bool(message.stCompleted100Episodes); + } + if (message.isInsuranceUsed === true) { + writer.uint32(88).bool(message.isInsuranceUsed); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultRequest_StoryResult { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveGameResultRequest_StoryResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.stPlayCount = reader.uint32(); + break; + case 9: + message.stPlayedStory = reader.uint32(); + break; + case 2: + message.tuningPoint = reader.uint32(); + break; + case 3: + message.stClearBits = reader.uint32(); + break; + case 4: + message.stClearDivCount = reader.uint32(); + break; + case 5: + message.stClearCount = reader.uint32(); + break; + case 6: + message.stLoseBits = longToNumber(reader.uint64() as Long); + break; + case 8: + message.stConsecutiveWins = reader.uint32(); + break; + case 10: + message.stCompleted100Episodes = reader.bool(); + break; + case 11: + message.isInsuranceUsed = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveGameResultRequest_StoryResult { + return { + stPlayCount: isSet(object.stPlayCount) ? Number(object.stPlayCount) : 0, + stPlayedStory: isSet(object.stPlayedStory) + ? Number(object.stPlayedStory) + : 0, + tuningPoint: isSet(object.tuningPoint) ? Number(object.tuningPoint) : 0, + stClearBits: isSet(object.stClearBits) ? Number(object.stClearBits) : 0, + stClearDivCount: isSet(object.stClearDivCount) + ? Number(object.stClearDivCount) + : 0, + stClearCount: isSet(object.stClearCount) + ? Number(object.stClearCount) + : 0, + stLoseBits: isSet(object.stLoseBits) ? Number(object.stLoseBits) : 0, + stConsecutiveWins: isSet(object.stConsecutiveWins) + ? Number(object.stConsecutiveWins) + : 0, + stCompleted100Episodes: isSet(object.stCompleted100Episodes) + ? Boolean(object.stCompleted100Episodes) + : false, + isInsuranceUsed: isSet(object.isInsuranceUsed) + ? Boolean(object.isInsuranceUsed) + : false, + }; + }, + + toJSON(message: SaveGameResultRequest_StoryResult): unknown { + const obj: any = {}; + message.stPlayCount !== undefined && + (obj.stPlayCount = Math.round(message.stPlayCount)); + message.stPlayedStory !== undefined && + (obj.stPlayedStory = Math.round(message.stPlayedStory)); + message.tuningPoint !== undefined && + (obj.tuningPoint = Math.round(message.tuningPoint)); + message.stClearBits !== undefined && + (obj.stClearBits = Math.round(message.stClearBits)); + message.stClearDivCount !== undefined && + (obj.stClearDivCount = Math.round(message.stClearDivCount)); + message.stClearCount !== undefined && + (obj.stClearCount = Math.round(message.stClearCount)); + message.stLoseBits !== undefined && + (obj.stLoseBits = Math.round(message.stLoseBits)); + message.stConsecutiveWins !== undefined && + (obj.stConsecutiveWins = Math.round(message.stConsecutiveWins)); + message.stCompleted100Episodes !== undefined && + (obj.stCompleted100Episodes = message.stCompleted100Episodes); + message.isInsuranceUsed !== undefined && + (obj.isInsuranceUsed = message.isInsuranceUsed); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveGameResultRequest_StoryResult { + const message = createBaseSaveGameResultRequest_StoryResult(); + message.stPlayCount = object.stPlayCount ?? 0; + message.stPlayedStory = object.stPlayedStory ?? 0; + message.tuningPoint = object.tuningPoint ?? 0; + message.stClearBits = object.stClearBits ?? 0; + message.stClearDivCount = object.stClearDivCount ?? 0; + message.stClearCount = object.stClearCount ?? 0; + message.stLoseBits = object.stLoseBits ?? 0; + message.stConsecutiveWins = object.stConsecutiveWins ?? 0; + message.stCompleted100Episodes = object.stCompleted100Episodes ?? false; + message.isInsuranceUsed = object.isInsuranceUsed ?? false; + return message; + }, +}; + +function createBaseSaveGameResultRequest_TimeAttackResult(): SaveGameResultRequest_TimeAttackResult { + return { + time: 0, + course: 0, + isMorning: false, + section1Time: 0, + section2Time: 0, + section3Time: 0, + section4Time: 0, + section5Time: 0, + section6Time: 0, + section7Time: 0, + wholeRank: 0, + modelRank: 0, + }; +} + +export const SaveGameResultRequest_TimeAttackResult = { + encode( + message: SaveGameResultRequest_TimeAttackResult, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.time !== 0) { + writer.uint32(8).uint32(message.time); + } + if (message.course !== 0) { + writer.uint32(16).uint32(message.course); + } + if (message.isMorning === true) { + writer.uint32(96).bool(message.isMorning); + } + if (message.section1Time !== 0) { + writer.uint32(24).uint32(message.section1Time); + } + if (message.section2Time !== 0) { + writer.uint32(32).uint32(message.section2Time); + } + if (message.section3Time !== 0) { + writer.uint32(40).uint32(message.section3Time); + } + if (message.section4Time !== 0) { + writer.uint32(48).uint32(message.section4Time); + } + if (message.section5Time !== 0) { + writer.uint32(56).uint32(message.section5Time); + } + if (message.section6Time !== 0) { + writer.uint32(64).uint32(message.section6Time); + } + if (message.section7Time !== 0) { + writer.uint32(72).uint32(message.section7Time); + } + if (message.wholeRank !== 0) { + writer.uint32(80).uint32(message.wholeRank); + } + if (message.modelRank !== 0) { + writer.uint32(88).uint32(message.modelRank); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultRequest_TimeAttackResult { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveGameResultRequest_TimeAttackResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.time = reader.uint32(); + break; + case 2: + message.course = reader.uint32(); + break; + case 12: + message.isMorning = reader.bool(); + break; + case 3: + message.section1Time = reader.uint32(); + break; + case 4: + message.section2Time = reader.uint32(); + break; + case 5: + message.section3Time = reader.uint32(); + break; + case 6: + message.section4Time = reader.uint32(); + break; + case 7: + message.section5Time = reader.uint32(); + break; + case 8: + message.section6Time = reader.uint32(); + break; + case 9: + message.section7Time = reader.uint32(); + break; + case 10: + message.wholeRank = reader.uint32(); + break; + case 11: + message.modelRank = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveGameResultRequest_TimeAttackResult { + return { + time: isSet(object.time) ? Number(object.time) : 0, + course: isSet(object.course) ? Number(object.course) : 0, + isMorning: isSet(object.isMorning) ? Boolean(object.isMorning) : false, + section1Time: isSet(object.section1Time) + ? Number(object.section1Time) + : 0, + section2Time: isSet(object.section2Time) + ? Number(object.section2Time) + : 0, + section3Time: isSet(object.section3Time) + ? Number(object.section3Time) + : 0, + section4Time: isSet(object.section4Time) + ? Number(object.section4Time) + : 0, + section5Time: isSet(object.section5Time) + ? Number(object.section5Time) + : 0, + section6Time: isSet(object.section6Time) + ? Number(object.section6Time) + : 0, + section7Time: isSet(object.section7Time) + ? Number(object.section7Time) + : 0, + wholeRank: isSet(object.wholeRank) ? Number(object.wholeRank) : 0, + modelRank: isSet(object.modelRank) ? Number(object.modelRank) : 0, + }; + }, + + toJSON(message: SaveGameResultRequest_TimeAttackResult): unknown { + const obj: any = {}; + message.time !== undefined && (obj.time = Math.round(message.time)); + message.course !== undefined && (obj.course = Math.round(message.course)); + message.isMorning !== undefined && (obj.isMorning = message.isMorning); + message.section1Time !== undefined && + (obj.section1Time = Math.round(message.section1Time)); + message.section2Time !== undefined && + (obj.section2Time = Math.round(message.section2Time)); + message.section3Time !== undefined && + (obj.section3Time = Math.round(message.section3Time)); + message.section4Time !== undefined && + (obj.section4Time = Math.round(message.section4Time)); + message.section5Time !== undefined && + (obj.section5Time = Math.round(message.section5Time)); + message.section6Time !== undefined && + (obj.section6Time = Math.round(message.section6Time)); + message.section7Time !== undefined && + (obj.section7Time = Math.round(message.section7Time)); + message.wholeRank !== undefined && + (obj.wholeRank = Math.round(message.wholeRank)); + message.modelRank !== undefined && + (obj.modelRank = Math.round(message.modelRank)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveGameResultRequest_TimeAttackResult { + const message = createBaseSaveGameResultRequest_TimeAttackResult(); + message.time = object.time ?? 0; + message.course = object.course ?? 0; + message.isMorning = object.isMorning ?? false; + message.section1Time = object.section1Time ?? 0; + message.section2Time = object.section2Time ?? 0; + message.section3Time = object.section3Time ?? 0; + message.section4Time = object.section4Time ?? 0; + message.section5Time = object.section5Time ?? 0; + message.section6Time = object.section6Time ?? 0; + message.section7Time = object.section7Time ?? 0; + message.wholeRank = object.wholeRank ?? 0; + message.modelRank = object.modelRank ?? 0; + return message; + }, +}; + +function createBaseSaveGameResultRequest_VersusBattleResult(): SaveGameResultRequest_VersusBattleResult { + return { + result: 0, + survived: false, + opponentCarId: [], + numOfPlayers: 0, + area: 0, + isMorning: false, + vsPlayCount: 0, + vsBurstCount: 0, + vsStarCount: 0, + vsCoolOrWild: 0, + vsSmoothOrRough: 0, + vsTripleStarMedals: 0, + vsDoubleStarMedals: 0, + vsSingleStarMedals: 0, + vsPlainMedals: 0, + }; +} + +export const SaveGameResultRequest_VersusBattleResult = { + encode( + message: SaveGameResultRequest_VersusBattleResult, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.result !== 0) { + writer.uint32(8).uint32(message.result); + } + if (message.survived === true) { + writer.uint32(16).bool(message.survived); + } + writer.uint32(26).fork(); + for (const v of message.opponentCarId) { + writer.uint32(v); + } + writer.ldelim(); + if (message.numOfPlayers !== 0) { + writer.uint32(40).uint32(message.numOfPlayers); + } + if (message.area !== 0) { + writer.uint32(136).uint32(message.area); + } + if (message.isMorning === true) { + writer.uint32(144).bool(message.isMorning); + } + if (message.vsPlayCount !== 0) { + writer.uint32(48).uint32(message.vsPlayCount); + } + if (message.vsBurstCount !== 0) { + writer.uint32(56).uint32(message.vsBurstCount); + } + if (message.vsStarCount !== 0) { + writer.uint32(64).uint32(message.vsStarCount); + } + if (message.vsCoolOrWild !== 0) { + writer.uint32(72).sint32(message.vsCoolOrWild); + } + if (message.vsSmoothOrRough !== 0) { + writer.uint32(80).sint32(message.vsSmoothOrRough); + } + if (message.vsTripleStarMedals !== 0) { + writer.uint32(88).uint32(message.vsTripleStarMedals); + } + if (message.vsDoubleStarMedals !== 0) { + writer.uint32(96).uint32(message.vsDoubleStarMedals); + } + if (message.vsSingleStarMedals !== 0) { + writer.uint32(104).uint32(message.vsSingleStarMedals); + } + if (message.vsPlainMedals !== 0) { + writer.uint32(112).uint32(message.vsPlainMedals); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultRequest_VersusBattleResult { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveGameResultRequest_VersusBattleResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.result = reader.uint32(); + break; + case 2: + message.survived = reader.bool(); + break; + case 3: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.opponentCarId.push(reader.uint32()); + } + } else { + message.opponentCarId.push(reader.uint32()); + } + break; + case 5: + message.numOfPlayers = reader.uint32(); + break; + case 17: + message.area = reader.uint32(); + break; + case 18: + message.isMorning = reader.bool(); + break; + case 6: + message.vsPlayCount = reader.uint32(); + break; + case 7: + message.vsBurstCount = reader.uint32(); + break; + case 8: + message.vsStarCount = reader.uint32(); + break; + case 9: + message.vsCoolOrWild = reader.sint32(); + break; + case 10: + message.vsSmoothOrRough = reader.sint32(); + break; + case 11: + message.vsTripleStarMedals = reader.uint32(); + break; + case 12: + message.vsDoubleStarMedals = reader.uint32(); + break; + case 13: + message.vsSingleStarMedals = reader.uint32(); + break; + case 14: + message.vsPlainMedals = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveGameResultRequest_VersusBattleResult { + return { + result: isSet(object.result) ? Number(object.result) : 0, + survived: isSet(object.survived) ? Boolean(object.survived) : false, + opponentCarId: Array.isArray(object?.opponentCarId) + ? object.opponentCarId.map((e: any) => Number(e)) + : [], + numOfPlayers: isSet(object.numOfPlayers) + ? Number(object.numOfPlayers) + : 0, + area: isSet(object.area) ? Number(object.area) : 0, + isMorning: isSet(object.isMorning) ? Boolean(object.isMorning) : false, + vsPlayCount: isSet(object.vsPlayCount) ? Number(object.vsPlayCount) : 0, + vsBurstCount: isSet(object.vsBurstCount) + ? Number(object.vsBurstCount) + : 0, + vsStarCount: isSet(object.vsStarCount) ? Number(object.vsStarCount) : 0, + vsCoolOrWild: isSet(object.vsCoolOrWild) + ? Number(object.vsCoolOrWild) + : 0, + vsSmoothOrRough: isSet(object.vsSmoothOrRough) + ? Number(object.vsSmoothOrRough) + : 0, + vsTripleStarMedals: isSet(object.vsTripleStarMedals) + ? Number(object.vsTripleStarMedals) + : 0, + vsDoubleStarMedals: isSet(object.vsDoubleStarMedals) + ? Number(object.vsDoubleStarMedals) + : 0, + vsSingleStarMedals: isSet(object.vsSingleStarMedals) + ? Number(object.vsSingleStarMedals) + : 0, + vsPlainMedals: isSet(object.vsPlainMedals) + ? Number(object.vsPlainMedals) + : 0, + }; + }, + + toJSON(message: SaveGameResultRequest_VersusBattleResult): unknown { + const obj: any = {}; + message.result !== undefined && (obj.result = Math.round(message.result)); + message.survived !== undefined && (obj.survived = message.survived); + if (message.opponentCarId) { + obj.opponentCarId = message.opponentCarId.map((e) => Math.round(e)); + } else { + obj.opponentCarId = []; + } + message.numOfPlayers !== undefined && + (obj.numOfPlayers = Math.round(message.numOfPlayers)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.isMorning !== undefined && (obj.isMorning = message.isMorning); + message.vsPlayCount !== undefined && + (obj.vsPlayCount = Math.round(message.vsPlayCount)); + message.vsBurstCount !== undefined && + (obj.vsBurstCount = Math.round(message.vsBurstCount)); + message.vsStarCount !== undefined && + (obj.vsStarCount = Math.round(message.vsStarCount)); + message.vsCoolOrWild !== undefined && + (obj.vsCoolOrWild = Math.round(message.vsCoolOrWild)); + message.vsSmoothOrRough !== undefined && + (obj.vsSmoothOrRough = Math.round(message.vsSmoothOrRough)); + message.vsTripleStarMedals !== undefined && + (obj.vsTripleStarMedals = Math.round(message.vsTripleStarMedals)); + message.vsDoubleStarMedals !== undefined && + (obj.vsDoubleStarMedals = Math.round(message.vsDoubleStarMedals)); + message.vsSingleStarMedals !== undefined && + (obj.vsSingleStarMedals = Math.round(message.vsSingleStarMedals)); + message.vsPlainMedals !== undefined && + (obj.vsPlainMedals = Math.round(message.vsPlainMedals)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveGameResultRequest_VersusBattleResult { + const message = createBaseSaveGameResultRequest_VersusBattleResult(); + message.result = object.result ?? 0; + message.survived = object.survived ?? false; + message.opponentCarId = object.opponentCarId?.map((e) => e) || []; + message.numOfPlayers = object.numOfPlayers ?? 0; + message.area = object.area ?? 0; + message.isMorning = object.isMorning ?? false; + message.vsPlayCount = object.vsPlayCount ?? 0; + message.vsBurstCount = object.vsBurstCount ?? 0; + message.vsStarCount = object.vsStarCount ?? 0; + message.vsCoolOrWild = object.vsCoolOrWild ?? 0; + message.vsSmoothOrRough = object.vsSmoothOrRough ?? 0; + message.vsTripleStarMedals = object.vsTripleStarMedals ?? 0; + message.vsDoubleStarMedals = object.vsDoubleStarMedals ?? 0; + message.vsSingleStarMedals = object.vsSingleStarMedals ?? 0; + message.vsPlainMedals = object.vsPlainMedals ?? 0; + return message; + }, +}; + +function createBaseSaveGameResultRequest_GhostBattleResult(): SaveGameResultRequest_GhostBattleResult { + return { + opponents: [], + path: 0, + isMorning: false, + selectionMethod: 1, + stampSheetCount: 0, + stampSheet: [], + rgStamp: 0, + confirmedTransferredStampTargetCarIds: [], + rgPlayCount: 0, + dressupLevel: 0, + dressupPoint: 0, + rgRegionMapScore: [], + competitionId: 0, + periodId: 0, + brakingPoint: 0, + acquireCrown: false, + acquireAllCrowns: false, + }; +} + +export const SaveGameResultRequest_GhostBattleResult = { + encode( + message: SaveGameResultRequest_GhostBattleResult, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.opponents) { + SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent.encode( + v!, + writer.uint32(10).fork() + ).ldelim(); + } + if (message.path !== 0) { + writer.uint32(24).uint32(message.path); + } + if (message.isMorning === true) { + writer.uint32(200).bool(message.isMorning); + } + if (message.selectionMethod !== 1) { + writer.uint32(32).int32(message.selectionMethod); + } + if (message.stampSheetCount !== 0) { + writer.uint32(40).uint32(message.stampSheetCount); + } + writer.uint32(50).fork(); + for (const v of message.stampSheet) { + writer.uint32(v); + } + writer.ldelim(); + if (message.rgStamp !== 0) { + writer.uint32(184).uint32(message.rgStamp); + } + writer.uint32(194).fork(); + for (const v of message.confirmedTransferredStampTargetCarIds) { + writer.uint32(v); + } + writer.ldelim(); + if (message.rgPlayCount !== 0) { + writer.uint32(64).uint32(message.rgPlayCount); + } + if (message.dressupLevel !== 0) { + writer.uint32(80).uint32(message.dressupLevel); + } + if (message.dressupPoint !== 0) { + writer.uint32(88).uint32(message.dressupPoint); + } + writer.uint32(114).fork(); + for (const v of message.rgRegionMapScore) { + writer.uint32(v); + } + writer.ldelim(); + if (message.competitionId !== 0) { + writer.uint32(128).uint32(message.competitionId); + } + if (message.periodId !== 0) { + writer.uint32(136).uint32(message.periodId); + } + if (message.brakingPoint !== 0) { + writer.uint32(144).uint32(message.brakingPoint); + } + if (message.acquireCrown === true) { + writer.uint32(160).bool(message.acquireCrown); + } + if (message.acquireAllCrowns === true) { + writer.uint32(168).bool(message.acquireAllCrowns); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultRequest_GhostBattleResult { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveGameResultRequest_GhostBattleResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.opponents.push( + SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent.decode( + reader, + reader.uint32() + ) + ); + break; + case 3: + message.path = reader.uint32(); + break; + case 25: + message.isMorning = reader.bool(); + break; + case 4: + message.selectionMethod = reader.int32() as any; + break; + case 5: + message.stampSheetCount = reader.uint32(); + break; + case 6: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.stampSheet.push(reader.uint32()); + } + } else { + message.stampSheet.push(reader.uint32()); + } + break; + case 23: + message.rgStamp = reader.uint32(); + break; + case 24: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.confirmedTransferredStampTargetCarIds.push( + reader.uint32() + ); + } + } else { + message.confirmedTransferredStampTargetCarIds.push(reader.uint32()); + } + break; + case 8: + message.rgPlayCount = reader.uint32(); + break; + case 10: + message.dressupLevel = reader.uint32(); + break; + case 11: + message.dressupPoint = reader.uint32(); + break; + case 14: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.rgRegionMapScore.push(reader.uint32()); + } + } else { + message.rgRegionMapScore.push(reader.uint32()); + } + break; + case 16: + message.competitionId = reader.uint32(); + break; + case 17: + message.periodId = reader.uint32(); + break; + case 18: + message.brakingPoint = reader.uint32(); + break; + case 20: + message.acquireCrown = reader.bool(); + break; + case 21: + message.acquireAllCrowns = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveGameResultRequest_GhostBattleResult { + return { + opponents: Array.isArray(object?.opponents) + ? object.opponents.map((e: any) => + SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent.fromJSON( + e + ) + ) + : [], + path: isSet(object.path) ? Number(object.path) : 0, + isMorning: isSet(object.isMorning) ? Boolean(object.isMorning) : false, + selectionMethod: isSet(object.selectionMethod) + ? ghostSelectionMethodFromJSON(object.selectionMethod) + : 1, + stampSheetCount: isSet(object.stampSheetCount) + ? Number(object.stampSheetCount) + : 0, + stampSheet: Array.isArray(object?.stampSheet) + ? object.stampSheet.map((e: any) => Number(e)) + : [], + rgStamp: isSet(object.rgStamp) ? Number(object.rgStamp) : 0, + confirmedTransferredStampTargetCarIds: Array.isArray( + object?.confirmedTransferredStampTargetCarIds + ) + ? object.confirmedTransferredStampTargetCarIds.map((e: any) => + Number(e) + ) + : [], + rgPlayCount: isSet(object.rgPlayCount) ? Number(object.rgPlayCount) : 0, + dressupLevel: isSet(object.dressupLevel) + ? Number(object.dressupLevel) + : 0, + dressupPoint: isSet(object.dressupPoint) + ? Number(object.dressupPoint) + : 0, + rgRegionMapScore: Array.isArray(object?.rgRegionMapScore) + ? object.rgRegionMapScore.map((e: any) => Number(e)) + : [], + competitionId: isSet(object.competitionId) + ? Number(object.competitionId) + : 0, + periodId: isSet(object.periodId) ? Number(object.periodId) : 0, + brakingPoint: isSet(object.brakingPoint) + ? Number(object.brakingPoint) + : 0, + acquireCrown: isSet(object.acquireCrown) + ? Boolean(object.acquireCrown) + : false, + acquireAllCrowns: isSet(object.acquireAllCrowns) + ? Boolean(object.acquireAllCrowns) + : false, + }; + }, + + toJSON(message: SaveGameResultRequest_GhostBattleResult): unknown { + const obj: any = {}; + if (message.opponents) { + obj.opponents = message.opponents.map((e) => + e + ? SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent.toJSON( + e + ) + : undefined + ); + } else { + obj.opponents = []; + } + message.path !== undefined && (obj.path = Math.round(message.path)); + message.isMorning !== undefined && (obj.isMorning = message.isMorning); + message.selectionMethod !== undefined && + (obj.selectionMethod = ghostSelectionMethodToJSON( + message.selectionMethod + )); + message.stampSheetCount !== undefined && + (obj.stampSheetCount = Math.round(message.stampSheetCount)); + if (message.stampSheet) { + obj.stampSheet = message.stampSheet.map((e) => Math.round(e)); + } else { + obj.stampSheet = []; + } + message.rgStamp !== undefined && + (obj.rgStamp = Math.round(message.rgStamp)); + if (message.confirmedTransferredStampTargetCarIds) { + obj.confirmedTransferredStampTargetCarIds = + message.confirmedTransferredStampTargetCarIds.map((e) => Math.round(e)); + } else { + obj.confirmedTransferredStampTargetCarIds = []; + } + message.rgPlayCount !== undefined && + (obj.rgPlayCount = Math.round(message.rgPlayCount)); + message.dressupLevel !== undefined && + (obj.dressupLevel = Math.round(message.dressupLevel)); + message.dressupPoint !== undefined && + (obj.dressupPoint = Math.round(message.dressupPoint)); + if (message.rgRegionMapScore) { + obj.rgRegionMapScore = message.rgRegionMapScore.map((e) => Math.round(e)); + } else { + obj.rgRegionMapScore = []; + } + message.competitionId !== undefined && + (obj.competitionId = Math.round(message.competitionId)); + message.periodId !== undefined && + (obj.periodId = Math.round(message.periodId)); + message.brakingPoint !== undefined && + (obj.brakingPoint = Math.round(message.brakingPoint)); + message.acquireCrown !== undefined && + (obj.acquireCrown = message.acquireCrown); + message.acquireAllCrowns !== undefined && + (obj.acquireAllCrowns = message.acquireAllCrowns); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveGameResultRequest_GhostBattleResult { + const message = createBaseSaveGameResultRequest_GhostBattleResult(); + message.opponents = + object.opponents?.map((e) => + SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent.fromPartial( + e + ) + ) || []; + message.path = object.path ?? 0; + message.isMorning = object.isMorning ?? false; + message.selectionMethod = object.selectionMethod ?? 1; + message.stampSheetCount = object.stampSheetCount ?? 0; + message.stampSheet = object.stampSheet?.map((e) => e) || []; + message.rgStamp = object.rgStamp ?? 0; + message.confirmedTransferredStampTargetCarIds = + object.confirmedTransferredStampTargetCarIds?.map((e) => e) || []; + message.rgPlayCount = object.rgPlayCount ?? 0; + message.dressupLevel = object.dressupLevel ?? 0; + message.dressupPoint = object.dressupPoint ?? 0; + message.rgRegionMapScore = object.rgRegionMapScore?.map((e) => e) || []; + message.competitionId = object.competitionId ?? 0; + message.periodId = object.periodId ?? 0; + message.brakingPoint = object.brakingPoint ?? 0; + message.acquireCrown = object.acquireCrown ?? false; + message.acquireAllCrowns = object.acquireAllCrowns ?? false; + return message; + }, +}; + +function createBaseSaveGameResultRequest_GhostBattleResult_GhostBattleOpponent(): SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent { + return { + result: 0, + carId: 0, + tunePower: 0, + tuneHandling: 0, + receiveStamp: false, + }; +} + +export const SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent = { + encode( + message: SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.result !== 0) { + writer.uint32(8).sint32(message.result); + } + if (message.carId !== 0) { + writer.uint32(16).uint32(message.carId); + } + if (message.tunePower !== 0) { + writer.uint32(24).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(32).uint32(message.tuneHandling); + } + if (message.receiveStamp === true) { + writer.uint32(40).bool(message.receiveStamp); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = + createBaseSaveGameResultRequest_GhostBattleResult_GhostBattleOpponent(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.result = reader.sint32(); + break; + case 2: + message.carId = reader.uint32(); + break; + case 3: + message.tunePower = reader.uint32(); + break; + case 4: + message.tuneHandling = reader.uint32(); + break; + case 5: + message.receiveStamp = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON( + object: any + ): SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent { + return { + result: isSet(object.result) ? Number(object.result) : 0, + carId: isSet(object.carId) ? Number(object.carId) : 0, + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + receiveStamp: isSet(object.receiveStamp) + ? Boolean(object.receiveStamp) + : false, + }; + }, + + toJSON( + message: SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent + ): unknown { + const obj: any = {}; + message.result !== undefined && (obj.result = Math.round(message.result)); + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.receiveStamp !== undefined && + (obj.receiveStamp = message.receiveStamp); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveGameResultRequest_GhostBattleResult_GhostBattleOpponent { + const message = + createBaseSaveGameResultRequest_GhostBattleResult_GhostBattleOpponent(); + message.result = object.result ?? 0; + message.carId = object.carId ?? 0; + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.receiveStamp = object.receiveStamp ?? false; + return message; + }, +}; + +function createBaseSaveGameResultResponse(): SaveGameResultResponse { + return { error: 0, ghostSessionId: 0, availableTickets: [] }; +} + +export const SaveGameResultResponse = { + encode( + message: SaveGameResultResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.ghostSessionId !== 0) { + writer.uint32(16).uint64(message.ghostSessionId); + } + for (const v of message.availableTickets) { + UserItem.encode(v!, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveGameResultResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveGameResultResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.ghostSessionId = longToNumber(reader.uint64() as Long); + break; + case 3: + message.availableTickets.push( + UserItem.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveGameResultResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + ghostSessionId: isSet(object.ghostSessionId) + ? Number(object.ghostSessionId) + : 0, + availableTickets: Array.isArray(object?.availableTickets) + ? object.availableTickets.map((e: any) => UserItem.fromJSON(e)) + : [], + }; + }, + + toJSON(message: SaveGameResultResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.ghostSessionId !== undefined && + (obj.ghostSessionId = Math.round(message.ghostSessionId)); + if (message.availableTickets) { + obj.availableTickets = message.availableTickets.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.availableTickets = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveGameResultResponse { + const message = createBaseSaveGameResultResponse(); + message.error = object.error ?? 0; + message.ghostSessionId = object.ghostSessionId ?? 0; + message.availableTickets = + object.availableTickets?.map((e) => UserItem.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseSaveChargeRequest(): SaveChargeRequest { + return { chargeLogs: [] }; +} + +export const SaveChargeRequest = { + encode( + message: SaveChargeRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.chargeLogs) { + SaveChargeRequest_ChargeLog.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): SaveChargeRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveChargeRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.chargeLogs.push( + SaveChargeRequest_ChargeLog.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveChargeRequest { + return { + chargeLogs: Array.isArray(object?.chargeLogs) + ? object.chargeLogs.map((e: any) => + SaveChargeRequest_ChargeLog.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: SaveChargeRequest): unknown { + const obj: any = {}; + if (message.chargeLogs) { + obj.chargeLogs = message.chargeLogs.map((e) => + e ? SaveChargeRequest_ChargeLog.toJSON(e) : undefined + ); + } else { + obj.chargeLogs = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveChargeRequest { + const message = createBaseSaveChargeRequest(); + message.chargeLogs = + object.chargeLogs?.map((e) => + SaveChargeRequest_ChargeLog.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseSaveChargeRequest_ChargeLog(): SaveChargeRequest_ChargeLog { + return { datetime: 0, pcbSerial: "", placeId: "", userId: 0 }; +} + +export const SaveChargeRequest_ChargeLog = { + encode( + message: SaveChargeRequest_ChargeLog, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.datetime !== 0) { + writer.uint32(8).uint32(message.datetime); + } + if (message.pcbSerial !== "") { + writer.uint32(18).string(message.pcbSerial); + } + if (message.placeId !== "") { + writer.uint32(26).string(message.placeId); + } + if (message.userId !== 0) { + writer.uint32(32).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveChargeRequest_ChargeLog { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveChargeRequest_ChargeLog(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.datetime = reader.uint32(); + break; + case 2: + message.pcbSerial = reader.string(); + break; + case 3: + message.placeId = reader.string(); + break; + case 4: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveChargeRequest_ChargeLog { + return { + datetime: isSet(object.datetime) ? Number(object.datetime) : 0, + pcbSerial: isSet(object.pcbSerial) ? String(object.pcbSerial) : "", + placeId: isSet(object.placeId) ? String(object.placeId) : "", + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: SaveChargeRequest_ChargeLog): unknown { + const obj: any = {}; + message.datetime !== undefined && + (obj.datetime = Math.round(message.datetime)); + message.pcbSerial !== undefined && (obj.pcbSerial = message.pcbSerial); + message.placeId !== undefined && (obj.placeId = message.placeId); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveChargeRequest_ChargeLog { + const message = createBaseSaveChargeRequest_ChargeLog(); + message.datetime = object.datetime ?? 0; + message.pcbSerial = object.pcbSerial ?? ""; + message.placeId = object.placeId ?? ""; + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseSaveChargeResponse(): SaveChargeResponse { + return { error: 0 }; +} + +export const SaveChargeResponse = { + encode( + message: SaveChargeResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): SaveChargeResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveChargeResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveChargeResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: SaveChargeResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveChargeResponse { + const message = createBaseSaveChargeResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseLoadGhostBattleInfoRequest(): LoadGhostBattleInfoRequest { + return { carId: 0 }; +} + +export const LoadGhostBattleInfoRequest = { + encode( + message: LoadGhostBattleInfoRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostBattleInfoRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostBattleInfoRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostBattleInfoRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + }; + }, + + toJSON(message: LoadGhostBattleInfoRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGhostBattleInfoRequest { + const message = createBaseLoadGhostBattleInfoRequest(); + message.carId = object.carId ?? 0; + return message; + }, +}; + +function createBaseLoadGhostBattleInfoResponse(): LoadGhostBattleInfoResponse { + return { + error: 0, + friendCars: [], + challengers: [], + stampTargetCars: [], + previousVersionStampTargetCars: [], + bookmarkedCars: [], + history: [], + weakenedCars: [], + stampSheetCount: 0, + stampSheet: [], + stampReturnStats: [], + }; +} + +export const LoadGhostBattleInfoResponse = { + encode( + message: LoadGhostBattleInfoResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.friendCars) { + FriendCar.encode(v!, writer.uint32(18).fork()).ldelim(); + } + for (const v of message.challengers) { + ChallengerCar.encode(v!, writer.uint32(26).fork()).ldelim(); + } + for (const v of message.stampTargetCars) { + StampTargetCar.encode(v!, writer.uint32(34).fork()).ldelim(); + } + for (const v of message.previousVersionStampTargetCars) { + PreviousVersionStampTargetCar.encode( + v!, + writer.uint32(98).fork() + ).ldelim(); + } + for (const v of message.bookmarkedCars) { + BookmarkedCar.encode(v!, writer.uint32(90).fork()).ldelim(); + } + for (const v of message.history) { + Car.encode(v!, writer.uint32(42).fork()).ldelim(); + } + for (const v of message.weakenedCars) { + LoadGhostBattleInfoResponse_WeakenedCar.encode( + v!, + writer.uint32(82).fork() + ).ldelim(); + } + if (message.stampSheetCount !== 0) { + writer.uint32(56).uint32(message.stampSheetCount); + } + writer.uint32(66).fork(); + for (const v of message.stampSheet) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(74).fork(); + for (const v of message.stampReturnStats) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostBattleInfoResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostBattleInfoResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.friendCars.push(FriendCar.decode(reader, reader.uint32())); + break; + case 3: + message.challengers.push( + ChallengerCar.decode(reader, reader.uint32()) + ); + break; + case 4: + message.stampTargetCars.push( + StampTargetCar.decode(reader, reader.uint32()) + ); + break; + case 12: + message.previousVersionStampTargetCars.push( + PreviousVersionStampTargetCar.decode(reader, reader.uint32()) + ); + break; + case 11: + message.bookmarkedCars.push( + BookmarkedCar.decode(reader, reader.uint32()) + ); + break; + case 5: + message.history.push(Car.decode(reader, reader.uint32())); + break; + case 10: + message.weakenedCars.push( + LoadGhostBattleInfoResponse_WeakenedCar.decode( + reader, + reader.uint32() + ) + ); + break; + case 7: + message.stampSheetCount = reader.uint32(); + break; + case 8: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.stampSheet.push(reader.uint32()); + } + } else { + message.stampSheet.push(reader.uint32()); + } + break; + case 9: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.stampReturnStats.push(reader.uint32()); + } + } else { + message.stampReturnStats.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostBattleInfoResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + friendCars: Array.isArray(object?.friendCars) + ? object.friendCars.map((e: any) => FriendCar.fromJSON(e)) + : [], + challengers: Array.isArray(object?.challengers) + ? object.challengers.map((e: any) => ChallengerCar.fromJSON(e)) + : [], + stampTargetCars: Array.isArray(object?.stampTargetCars) + ? object.stampTargetCars.map((e: any) => StampTargetCar.fromJSON(e)) + : [], + previousVersionStampTargetCars: Array.isArray( + object?.previousVersionStampTargetCars + ) + ? object.previousVersionStampTargetCars.map((e: any) => + PreviousVersionStampTargetCar.fromJSON(e) + ) + : [], + bookmarkedCars: Array.isArray(object?.bookmarkedCars) + ? object.bookmarkedCars.map((e: any) => BookmarkedCar.fromJSON(e)) + : [], + history: Array.isArray(object?.history) + ? object.history.map((e: any) => Car.fromJSON(e)) + : [], + weakenedCars: Array.isArray(object?.weakenedCars) + ? object.weakenedCars.map((e: any) => + LoadGhostBattleInfoResponse_WeakenedCar.fromJSON(e) + ) + : [], + stampSheetCount: isSet(object.stampSheetCount) + ? Number(object.stampSheetCount) + : 0, + stampSheet: Array.isArray(object?.stampSheet) + ? object.stampSheet.map((e: any) => Number(e)) + : [], + stampReturnStats: Array.isArray(object?.stampReturnStats) + ? object.stampReturnStats.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: LoadGhostBattleInfoResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.friendCars) { + obj.friendCars = message.friendCars.map((e) => + e ? FriendCar.toJSON(e) : undefined + ); + } else { + obj.friendCars = []; + } + if (message.challengers) { + obj.challengers = message.challengers.map((e) => + e ? ChallengerCar.toJSON(e) : undefined + ); + } else { + obj.challengers = []; + } + if (message.stampTargetCars) { + obj.stampTargetCars = message.stampTargetCars.map((e) => + e ? StampTargetCar.toJSON(e) : undefined + ); + } else { + obj.stampTargetCars = []; + } + if (message.previousVersionStampTargetCars) { + obj.previousVersionStampTargetCars = + message.previousVersionStampTargetCars.map((e) => + e ? PreviousVersionStampTargetCar.toJSON(e) : undefined + ); + } else { + obj.previousVersionStampTargetCars = []; + } + if (message.bookmarkedCars) { + obj.bookmarkedCars = message.bookmarkedCars.map((e) => + e ? BookmarkedCar.toJSON(e) : undefined + ); + } else { + obj.bookmarkedCars = []; + } + if (message.history) { + obj.history = message.history.map((e) => (e ? Car.toJSON(e) : undefined)); + } else { + obj.history = []; + } + if (message.weakenedCars) { + obj.weakenedCars = message.weakenedCars.map((e) => + e ? LoadGhostBattleInfoResponse_WeakenedCar.toJSON(e) : undefined + ); + } else { + obj.weakenedCars = []; + } + message.stampSheetCount !== undefined && + (obj.stampSheetCount = Math.round(message.stampSheetCount)); + if (message.stampSheet) { + obj.stampSheet = message.stampSheet.map((e) => Math.round(e)); + } else { + obj.stampSheet = []; + } + if (message.stampReturnStats) { + obj.stampReturnStats = message.stampReturnStats.map((e) => Math.round(e)); + } else { + obj.stampReturnStats = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGhostBattleInfoResponse { + const message = createBaseLoadGhostBattleInfoResponse(); + message.error = object.error ?? 0; + message.friendCars = + object.friendCars?.map((e) => FriendCar.fromPartial(e)) || []; + message.challengers = + object.challengers?.map((e) => ChallengerCar.fromPartial(e)) || []; + message.stampTargetCars = + object.stampTargetCars?.map((e) => StampTargetCar.fromPartial(e)) || []; + message.previousVersionStampTargetCars = + object.previousVersionStampTargetCars?.map((e) => + PreviousVersionStampTargetCar.fromPartial(e) + ) || []; + message.bookmarkedCars = + object.bookmarkedCars?.map((e) => BookmarkedCar.fromPartial(e)) || []; + message.history = object.history?.map((e) => Car.fromPartial(e)) || []; + message.weakenedCars = + object.weakenedCars?.map((e) => + LoadGhostBattleInfoResponse_WeakenedCar.fromPartial(e) + ) || []; + message.stampSheetCount = object.stampSheetCount ?? 0; + message.stampSheet = object.stampSheet?.map((e) => e) || []; + message.stampReturnStats = object.stampReturnStats?.map((e) => e) || []; + return message; + }, +}; + +function createBaseLoadGhostBattleInfoResponse_WeakenedCar(): LoadGhostBattleInfoResponse_WeakenedCar { + return { carId: 0, consecutiveLosses: 0 }; +} + +export const LoadGhostBattleInfoResponse_WeakenedCar = { + encode( + message: LoadGhostBattleInfoResponse_WeakenedCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.consecutiveLosses !== 0) { + writer.uint32(16).uint32(message.consecutiveLosses); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostBattleInfoResponse_WeakenedCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostBattleInfoResponse_WeakenedCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.consecutiveLosses = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostBattleInfoResponse_WeakenedCar { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + consecutiveLosses: isSet(object.consecutiveLosses) + ? Number(object.consecutiveLosses) + : 0, + }; + }, + + toJSON(message: LoadGhostBattleInfoResponse_WeakenedCar): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.consecutiveLosses !== undefined && + (obj.consecutiveLosses = Math.round(message.consecutiveLosses)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGhostBattleInfoResponse_WeakenedCar { + const message = createBaseLoadGhostBattleInfoResponse_WeakenedCar(); + message.carId = object.carId ?? 0; + message.consecutiveLosses = object.consecutiveLosses ?? 0; + return message; + }, +}; + +function createBaseLoadStampTargetRequest(): LoadStampTargetRequest { + return { carId: 0, needToPromote: false }; +} + +export const LoadStampTargetRequest = { + encode( + message: LoadStampTargetRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.needToPromote === true) { + writer.uint32(16).bool(message.needToPromote); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadStampTargetRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadStampTargetRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.needToPromote = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadStampTargetRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + needToPromote: isSet(object.needToPromote) + ? Boolean(object.needToPromote) + : false, + }; + }, + + toJSON(message: LoadStampTargetRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.needToPromote !== undefined && + (obj.needToPromote = message.needToPromote); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadStampTargetRequest { + const message = createBaseLoadStampTargetRequest(); + message.carId = object.carId ?? 0; + message.needToPromote = object.needToPromote ?? false; + return message; + }, +}; + +function createBaseLoadStampTargetResponse(): LoadStampTargetResponse { + return { error: 0, cars: [], challengers: [] }; +} + +export const LoadStampTargetResponse = { + encode( + message: LoadStampTargetResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.cars) { + StampTargetCar.encode(v!, writer.uint32(18).fork()).ldelim(); + } + for (const v of message.challengers) { + ChallengerCar.encode(v!, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadStampTargetResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadStampTargetResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.cars.push(StampTargetCar.decode(reader, reader.uint32())); + break; + case 3: + message.challengers.push( + ChallengerCar.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadStampTargetResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + cars: Array.isArray(object?.cars) + ? object.cars.map((e: any) => StampTargetCar.fromJSON(e)) + : [], + challengers: Array.isArray(object?.challengers) + ? object.challengers.map((e: any) => ChallengerCar.fromJSON(e)) + : [], + }; + }, + + toJSON(message: LoadStampTargetResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.cars) { + obj.cars = message.cars.map((e) => + e ? StampTargetCar.toJSON(e) : undefined + ); + } else { + obj.cars = []; + } + if (message.challengers) { + obj.challengers = message.challengers.map((e) => + e ? ChallengerCar.toJSON(e) : undefined + ); + } else { + obj.challengers = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadStampTargetResponse { + const message = createBaseLoadStampTargetResponse(); + message.error = object.error ?? 0; + message.cars = object.cars?.map((e) => StampTargetCar.fromPartial(e)) || []; + message.challengers = + object.challengers?.map((e) => ChallengerCar.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseLockStampTargetRequest(): LockStampTargetRequest { + return { carId: 0, targetCars: [] }; +} + +export const LockStampTargetRequest = { + encode( + message: LockStampTargetRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + writer.uint32(18).fork(); + for (const v of message.targetCars) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LockStampTargetRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLockStampTargetRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.targetCars.push(reader.uint32()); + } + } else { + message.targetCars.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LockStampTargetRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + targetCars: Array.isArray(object?.targetCars) + ? object.targetCars.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: LockStampTargetRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + if (message.targetCars) { + obj.targetCars = message.targetCars.map((e) => Math.round(e)); + } else { + obj.targetCars = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LockStampTargetRequest { + const message = createBaseLockStampTargetRequest(); + message.carId = object.carId ?? 0; + message.targetCars = object.targetCars?.map((e) => e) || []; + return message; + }, +}; + +function createBaseLockStampTargetResponse(): LockStampTargetResponse { + return { error: 0 }; +} + +export const LockStampTargetResponse = { + encode( + message: LockStampTargetResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LockStampTargetResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLockStampTargetResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LockStampTargetResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: LockStampTargetResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LockStampTargetResponse { + const message = createBaseLockStampTargetResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseLoadGhostCompetitionInfoRequest(): LoadGhostCompetitionInfoRequest { + return { carId: 0, competitionId: 0 }; +} + +export const LoadGhostCompetitionInfoRequest = { + encode( + message: LoadGhostCompetitionInfoRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.competitionId !== 0) { + writer.uint32(16).uint32(message.competitionId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostCompetitionInfoRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostCompetitionInfoRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.competitionId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostCompetitionInfoRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + competitionId: isSet(object.competitionId) + ? Number(object.competitionId) + : 0, + }; + }, + + toJSON(message: LoadGhostCompetitionInfoRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.competitionId !== undefined && + (obj.competitionId = Math.round(message.competitionId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGhostCompetitionInfoRequest { + const message = createBaseLoadGhostCompetitionInfoRequest(); + message.carId = object.carId ?? 0; + message.competitionId = object.competitionId ?? 0; + return message; + }, +}; + +function createBaseLoadGhostCompetitionInfoResponse(): LoadGhostCompetitionInfoResponse { + return { + error: 0, + periodId: 0, + closed: false, + brakingPoint: 0, + qualified: false, + topResults: [], + result: 0, + rank: 0, + parameters1: [], + parameters2: false, + }; +} + +export const LoadGhostCompetitionInfoResponse = { + encode( + message: LoadGhostCompetitionInfoResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.periodId !== 0) { + writer.uint32(16).uint32(message.periodId); + } + if (message.closed === true) { + writer.uint32(24).bool(message.closed); + } + if (message.brakingPoint !== 0) { + writer.uint32(32).uint32(message.brakingPoint); + } + if (message.qualified === true) { + writer.uint32(40).bool(message.qualified); + } + writer.uint32(50).fork(); + for (const v of message.topResults) { + writer.sint32(v); + } + writer.ldelim(); + if (message.result !== 0) { + writer.uint32(56).sint32(message.result); + } + if (message.rank !== 0) { + writer.uint32(64).uint32(message.rank); + } + writer.uint32(74).fork(); + for (const v of message.parameters1) { + writer.float(v); + } + writer.ldelim(); + if (message.parameters2 === true) { + writer.uint32(80).bool(message.parameters2); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostCompetitionInfoResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostCompetitionInfoResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.periodId = reader.uint32(); + break; + case 3: + message.closed = reader.bool(); + break; + case 4: + message.brakingPoint = reader.uint32(); + break; + case 5: + message.qualified = reader.bool(); + break; + case 6: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.topResults.push(reader.sint32()); + } + } else { + message.topResults.push(reader.sint32()); + } + break; + case 7: + message.result = reader.sint32(); + break; + case 8: + message.rank = reader.uint32(); + break; + case 9: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.parameters1.push(reader.float()); + } + } else { + message.parameters1.push(reader.float()); + } + break; + case 10: + message.parameters2 = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostCompetitionInfoResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + periodId: isSet(object.periodId) ? Number(object.periodId) : 0, + closed: isSet(object.closed) ? Boolean(object.closed) : false, + brakingPoint: isSet(object.brakingPoint) + ? Number(object.brakingPoint) + : 0, + qualified: isSet(object.qualified) ? Boolean(object.qualified) : false, + topResults: Array.isArray(object?.topResults) + ? object.topResults.map((e: any) => Number(e)) + : [], + result: isSet(object.result) ? Number(object.result) : 0, + rank: isSet(object.rank) ? Number(object.rank) : 0, + parameters1: Array.isArray(object?.parameters1) + ? object.parameters1.map((e: any) => Number(e)) + : [], + parameters2: isSet(object.parameters2) + ? Boolean(object.parameters2) + : false, + }; + }, + + toJSON(message: LoadGhostCompetitionInfoResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.periodId !== undefined && + (obj.periodId = Math.round(message.periodId)); + message.closed !== undefined && (obj.closed = message.closed); + message.brakingPoint !== undefined && + (obj.brakingPoint = Math.round(message.brakingPoint)); + message.qualified !== undefined && (obj.qualified = message.qualified); + if (message.topResults) { + obj.topResults = message.topResults.map((e) => Math.round(e)); + } else { + obj.topResults = []; + } + message.result !== undefined && (obj.result = Math.round(message.result)); + message.rank !== undefined && (obj.rank = Math.round(message.rank)); + if (message.parameters1) { + obj.parameters1 = message.parameters1.map((e) => e); + } else { + obj.parameters1 = []; + } + message.parameters2 !== undefined && + (obj.parameters2 = message.parameters2); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGhostCompetitionInfoResponse { + const message = createBaseLoadGhostCompetitionInfoResponse(); + message.error = object.error ?? 0; + message.periodId = object.periodId ?? 0; + message.closed = object.closed ?? false; + message.brakingPoint = object.brakingPoint ?? 0; + message.qualified = object.qualified ?? false; + message.topResults = object.topResults?.map((e) => e) || []; + message.result = object.result ?? 0; + message.rank = object.rank ?? 0; + message.parameters1 = object.parameters1?.map((e) => e) || []; + message.parameters2 = object.parameters2 ?? false; + return message; + }, +}; + +function createBaseLoadTimeAttackRecordRequest(): LoadTimeAttackRecordRequest { + return { carId: 0, model: 0, course: 0 }; +} + +export const LoadTimeAttackRecordRequest = { + encode( + message: LoadTimeAttackRecordRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.model !== 0) { + writer.uint32(16).uint32(message.model); + } + if (message.course !== 0) { + writer.uint32(24).uint32(message.course); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadTimeAttackRecordRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadTimeAttackRecordRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.model = reader.uint32(); + break; + case 3: + message.course = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadTimeAttackRecordRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + model: isSet(object.model) ? Number(object.model) : 0, + course: isSet(object.course) ? Number(object.course) : 0, + }; + }, + + toJSON(message: LoadTimeAttackRecordRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.model !== undefined && (obj.model = Math.round(message.model)); + message.course !== undefined && (obj.course = Math.round(message.course)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadTimeAttackRecordRequest { + const message = createBaseLoadTimeAttackRecordRequest(); + message.carId = object.carId ?? 0; + message.model = object.model ?? 0; + message.course = object.course ?? 0; + return message; + }, +}; + +function createBaseLoadTimeAttackRecordResponse(): LoadTimeAttackRecordResponse { + return { + error: 0, + wholeRanking: [], + modelRanking: [], + personalBestTime: 0, + pbSection1Time: 0, + pbSection2Time: 0, + pbSection3Time: 0, + pbSection4Time: 0, + pbSection5Time: 0, + pbSection6Time: 0, + pbSection7Time: 0, + }; +} + +export const LoadTimeAttackRecordResponse = { + encode( + message: LoadTimeAttackRecordResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + writer.uint32(18).fork(); + for (const v of message.wholeRanking) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(26).fork(); + for (const v of message.modelRanking) { + writer.uint32(v); + } + writer.ldelim(); + if (message.personalBestTime !== 0) { + writer.uint32(32).uint32(message.personalBestTime); + } + if (message.pbSection1Time !== 0) { + writer.uint32(40).uint32(message.pbSection1Time); + } + if (message.pbSection2Time !== 0) { + writer.uint32(48).uint32(message.pbSection2Time); + } + if (message.pbSection3Time !== 0) { + writer.uint32(56).uint32(message.pbSection3Time); + } + if (message.pbSection4Time !== 0) { + writer.uint32(64).uint32(message.pbSection4Time); + } + if (message.pbSection5Time !== 0) { + writer.uint32(72).uint32(message.pbSection5Time); + } + if (message.pbSection6Time !== 0) { + writer.uint32(80).uint32(message.pbSection6Time); + } + if (message.pbSection7Time !== 0) { + writer.uint32(88).uint32(message.pbSection7Time); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadTimeAttackRecordResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadTimeAttackRecordResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.wholeRanking.push(reader.uint32()); + } + } else { + message.wholeRanking.push(reader.uint32()); + } + break; + case 3: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.modelRanking.push(reader.uint32()); + } + } else { + message.modelRanking.push(reader.uint32()); + } + break; + case 4: + message.personalBestTime = reader.uint32(); + break; + case 5: + message.pbSection1Time = reader.uint32(); + break; + case 6: + message.pbSection2Time = reader.uint32(); + break; + case 7: + message.pbSection3Time = reader.uint32(); + break; + case 8: + message.pbSection4Time = reader.uint32(); + break; + case 9: + message.pbSection5Time = reader.uint32(); + break; + case 10: + message.pbSection6Time = reader.uint32(); + break; + case 11: + message.pbSection7Time = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadTimeAttackRecordResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + wholeRanking: Array.isArray(object?.wholeRanking) + ? object.wholeRanking.map((e: any) => Number(e)) + : [], + modelRanking: Array.isArray(object?.modelRanking) + ? object.modelRanking.map((e: any) => Number(e)) + : [], + personalBestTime: isSet(object.personalBestTime) + ? Number(object.personalBestTime) + : 0, + pbSection1Time: isSet(object.pbSection1Time) + ? Number(object.pbSection1Time) + : 0, + pbSection2Time: isSet(object.pbSection2Time) + ? Number(object.pbSection2Time) + : 0, + pbSection3Time: isSet(object.pbSection3Time) + ? Number(object.pbSection3Time) + : 0, + pbSection4Time: isSet(object.pbSection4Time) + ? Number(object.pbSection4Time) + : 0, + pbSection5Time: isSet(object.pbSection5Time) + ? Number(object.pbSection5Time) + : 0, + pbSection6Time: isSet(object.pbSection6Time) + ? Number(object.pbSection6Time) + : 0, + pbSection7Time: isSet(object.pbSection7Time) + ? Number(object.pbSection7Time) + : 0, + }; + }, + + toJSON(message: LoadTimeAttackRecordResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.wholeRanking) { + obj.wholeRanking = message.wholeRanking.map((e) => Math.round(e)); + } else { + obj.wholeRanking = []; + } + if (message.modelRanking) { + obj.modelRanking = message.modelRanking.map((e) => Math.round(e)); + } else { + obj.modelRanking = []; + } + message.personalBestTime !== undefined && + (obj.personalBestTime = Math.round(message.personalBestTime)); + message.pbSection1Time !== undefined && + (obj.pbSection1Time = Math.round(message.pbSection1Time)); + message.pbSection2Time !== undefined && + (obj.pbSection2Time = Math.round(message.pbSection2Time)); + message.pbSection3Time !== undefined && + (obj.pbSection3Time = Math.round(message.pbSection3Time)); + message.pbSection4Time !== undefined && + (obj.pbSection4Time = Math.round(message.pbSection4Time)); + message.pbSection5Time !== undefined && + (obj.pbSection5Time = Math.round(message.pbSection5Time)); + message.pbSection6Time !== undefined && + (obj.pbSection6Time = Math.round(message.pbSection6Time)); + message.pbSection7Time !== undefined && + (obj.pbSection7Time = Math.round(message.pbSection7Time)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadTimeAttackRecordResponse { + const message = createBaseLoadTimeAttackRecordResponse(); + message.error = object.error ?? 0; + message.wholeRanking = object.wholeRanking?.map((e) => e) || []; + message.modelRanking = object.modelRanking?.map((e) => e) || []; + message.personalBestTime = object.personalBestTime ?? 0; + message.pbSection1Time = object.pbSection1Time ?? 0; + message.pbSection2Time = object.pbSection2Time ?? 0; + message.pbSection3Time = object.pbSection3Time ?? 0; + message.pbSection4Time = object.pbSection4Time ?? 0; + message.pbSection5Time = object.pbSection5Time ?? 0; + message.pbSection6Time = object.pbSection6Time ?? 0; + message.pbSection7Time = object.pbSection7Time ?? 0; + return message; + }, +}; + +function createBaseSaveTerminalResultRequest(): SaveTerminalResultRequest { + return { + userId: 0, + timestamp: 0, + carOrder: [], + confirmedTutorials: [], + garageMenuEntered: false, + }; +} + +export const SaveTerminalResultRequest = { + encode( + message: SaveTerminalResultRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + if (message.timestamp !== 0) { + writer.uint32(16).uint32(message.timestamp); + } + writer.uint32(26).fork(); + for (const v of message.carOrder) { + writer.uint32(v); + } + writer.ldelim(); + writer.uint32(42).fork(); + for (const v of message.confirmedTutorials) { + writer.int32(v); + } + writer.ldelim(); + if (message.garageMenuEntered === true) { + writer.uint32(64).bool(message.garageMenuEntered); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveTerminalResultRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveTerminalResultRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.timestamp = reader.uint32(); + break; + case 3: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.carOrder.push(reader.uint32()); + } + } else { + message.carOrder.push(reader.uint32()); + } + break; + case 5: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.confirmedTutorials.push(reader.int32() as any); + } + } else { + message.confirmedTutorials.push(reader.int32() as any); + } + break; + case 8: + message.garageMenuEntered = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveTerminalResultRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + carOrder: Array.isArray(object?.carOrder) + ? object.carOrder.map((e: any) => Number(e)) + : [], + confirmedTutorials: Array.isArray(object?.confirmedTutorials) + ? object.confirmedTutorials.map((e: any) => tutorialTypeFromJSON(e)) + : [], + garageMenuEntered: isSet(object.garageMenuEntered) + ? Boolean(object.garageMenuEntered) + : false, + }; + }, + + toJSON(message: SaveTerminalResultRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + if (message.carOrder) { + obj.carOrder = message.carOrder.map((e) => Math.round(e)); + } else { + obj.carOrder = []; + } + if (message.confirmedTutorials) { + obj.confirmedTutorials = message.confirmedTutorials.map((e) => + tutorialTypeToJSON(e) + ); + } else { + obj.confirmedTutorials = []; + } + message.garageMenuEntered !== undefined && + (obj.garageMenuEntered = message.garageMenuEntered); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveTerminalResultRequest { + const message = createBaseSaveTerminalResultRequest(); + message.userId = object.userId ?? 0; + message.timestamp = object.timestamp ?? 0; + message.carOrder = object.carOrder?.map((e) => e) || []; + message.confirmedTutorials = object.confirmedTutorials?.map((e) => e) || []; + message.garageMenuEntered = object.garageMenuEntered ?? false; + return message; + }, +}; + +function createBaseSaveTerminalResultResponse(): SaveTerminalResultResponse { + return { error: 0 }; +} + +export const SaveTerminalResultResponse = { + encode( + message: SaveTerminalResultResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveTerminalResultResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveTerminalResultResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveTerminalResultResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: SaveTerminalResultResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveTerminalResultResponse { + const message = createBaseSaveTerminalResultResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBasePingRequest(): PingRequest { + return { ping: 0 }; +} + +export const PingRequest = { + encode( + message: PingRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.ping !== 0) { + writer.uint32(8).uint32(message.ping); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): PingRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePingRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.ping = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): PingRequest { + return { + ping: isSet(object.ping) ? Number(object.ping) : 0, + }; + }, + + toJSON(message: PingRequest): unknown { + const obj: any = {}; + message.ping !== undefined && (obj.ping = Math.round(message.ping)); + return obj; + }, + + fromPartial, I>>( + object: I + ): PingRequest { + const message = createBasePingRequest(); + message.ping = object.ping ?? 0; + return message; + }, +}; + +function createBasePingResponse(): PingResponse { + return { error: 0, pong: 0 }; +} + +export const PingResponse = { + encode( + message: PingResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.pong !== 0) { + writer.uint32(16).uint32(message.pong); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): PingResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePingResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.pong = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): PingResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + pong: isSet(object.pong) ? Number(object.pong) : 0, + }; + }, + + toJSON(message: PingResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.pong !== undefined && (obj.pong = Math.round(message.pong)); + return obj; + }, + + fromPartial, I>>( + object: I + ): PingResponse { + const message = createBasePingResponse(); + message.error = object.error ?? 0; + message.pong = object.pong ?? 0; + return message; + }, +}; + +function createBaseLoadTerminalInformationRequest(): LoadTerminalInformationRequest { + return { userId: 0 }; +} + +export const LoadTerminalInformationRequest = { + encode( + message: LoadTerminalInformationRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadTerminalInformationRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadTerminalInformationRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadTerminalInformationRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: LoadTerminalInformationRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadTerminalInformationRequest { + const message = createBaseLoadTerminalInformationRequest(); + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseLoadTerminalInformationResponse(): LoadTerminalInformationResponse { + return { + error: 0, + prizeReceivable: false, + noticeEntries: [], + noticeMessage: [], + noticeWindow: [], + noticeWindowMessage: [], + transferNotice: undefined, + announceFeature: false, + freeScratched: false, + restrictedModels: [], + }; +} + +export const LoadTerminalInformationResponse = { + encode( + message: LoadTerminalInformationResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.prizeReceivable === true) { + writer.uint32(136).bool(message.prizeReceivable); + } + for (const v of message.noticeEntries) { + LoadTerminalInformationResponse_TerminalNotice.encode( + v!, + writer.uint32(82).fork() + ).ldelim(); + } + for (const v of message.noticeMessage) { + writer.uint32(90).string(v!); + } + writer.uint32(98).fork(); + for (const v of message.noticeWindow) { + writer.int32(v); + } + writer.ldelim(); + for (const v of message.noticeWindowMessage) { + writer.uint32(106).string(v!); + } + if (message.transferNotice !== undefined) { + TransferNotice.encode( + message.transferNotice, + writer.uint32(114).fork() + ).ldelim(); + } + if (message.announceFeature === true) { + writer.uint32(128).bool(message.announceFeature); + } + if (message.freeScratched === true) { + writer.uint32(144).bool(message.freeScratched); + } + writer.uint32(18).fork(); + for (const v of message.restrictedModels) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadTerminalInformationResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadTerminalInformationResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 17: + message.prizeReceivable = reader.bool(); + break; + case 10: + message.noticeEntries.push( + LoadTerminalInformationResponse_TerminalNotice.decode( + reader, + reader.uint32() + ) + ); + break; + case 11: + message.noticeMessage.push(reader.string()); + break; + case 12: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.noticeWindow.push(reader.int32() as any); + } + } else { + message.noticeWindow.push(reader.int32() as any); + } + break; + case 13: + message.noticeWindowMessage.push(reader.string()); + break; + case 14: + message.transferNotice = TransferNotice.decode( + reader, + reader.uint32() + ); + break; + case 16: + message.announceFeature = reader.bool(); + break; + case 18: + message.freeScratched = reader.bool(); + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.restrictedModels.push(reader.uint32()); + } + } else { + message.restrictedModels.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadTerminalInformationResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + prizeReceivable: isSet(object.prizeReceivable) + ? Boolean(object.prizeReceivable) + : false, + noticeEntries: Array.isArray(object?.noticeEntries) + ? object.noticeEntries.map((e: any) => + LoadTerminalInformationResponse_TerminalNotice.fromJSON(e) + ) + : [], + noticeMessage: Array.isArray(object?.noticeMessage) + ? object.noticeMessage.map((e: any) => String(e)) + : [], + noticeWindow: Array.isArray(object?.noticeWindow) + ? object.noticeWindow.map((e: any) => noticeEntryFromJSON(e)) + : [], + noticeWindowMessage: Array.isArray(object?.noticeWindowMessage) + ? object.noticeWindowMessage.map((e: any) => String(e)) + : [], + transferNotice: isSet(object.transferNotice) + ? TransferNotice.fromJSON(object.transferNotice) + : undefined, + announceFeature: isSet(object.announceFeature) + ? Boolean(object.announceFeature) + : false, + freeScratched: isSet(object.freeScratched) + ? Boolean(object.freeScratched) + : false, + restrictedModels: Array.isArray(object?.restrictedModels) + ? object.restrictedModels.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: LoadTerminalInformationResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.prizeReceivable !== undefined && + (obj.prizeReceivable = message.prizeReceivable); + if (message.noticeEntries) { + obj.noticeEntries = message.noticeEntries.map((e) => + e ? LoadTerminalInformationResponse_TerminalNotice.toJSON(e) : undefined + ); + } else { + obj.noticeEntries = []; + } + if (message.noticeMessage) { + obj.noticeMessage = message.noticeMessage.map((e) => e); + } else { + obj.noticeMessage = []; + } + if (message.noticeWindow) { + obj.noticeWindow = message.noticeWindow.map((e) => noticeEntryToJSON(e)); + } else { + obj.noticeWindow = []; + } + if (message.noticeWindowMessage) { + obj.noticeWindowMessage = message.noticeWindowMessage.map((e) => e); + } else { + obj.noticeWindowMessage = []; + } + message.transferNotice !== undefined && + (obj.transferNotice = message.transferNotice + ? TransferNotice.toJSON(message.transferNotice) + : undefined); + message.announceFeature !== undefined && + (obj.announceFeature = message.announceFeature); + message.freeScratched !== undefined && + (obj.freeScratched = message.freeScratched); + if (message.restrictedModels) { + obj.restrictedModels = message.restrictedModels.map((e) => Math.round(e)); + } else { + obj.restrictedModels = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadTerminalInformationResponse { + const message = createBaseLoadTerminalInformationResponse(); + message.error = object.error ?? 0; + message.prizeReceivable = object.prizeReceivable ?? false; + message.noticeEntries = + object.noticeEntries?.map((e) => + LoadTerminalInformationResponse_TerminalNotice.fromPartial(e) + ) || []; + message.noticeMessage = object.noticeMessage?.map((e) => e) || []; + message.noticeWindow = object.noticeWindow?.map((e) => e) || []; + message.noticeWindowMessage = + object.noticeWindowMessage?.map((e) => e) || []; + message.transferNotice = + object.transferNotice !== undefined && object.transferNotice !== null + ? TransferNotice.fromPartial(object.transferNotice) + : undefined; + message.announceFeature = object.announceFeature ?? false; + message.freeScratched = object.freeScratched ?? false; + message.restrictedModels = object.restrictedModels?.map((e) => e) || []; + return message; + }, +}; + +function createBaseLoadTerminalInformationResponse_TerminalNotice(): LoadTerminalInformationResponse_TerminalNotice { + return { noticeType: 1, field1: "", field2: 0, field3: 0 }; +} + +export const LoadTerminalInformationResponse_TerminalNotice = { + encode( + message: LoadTerminalInformationResponse_TerminalNotice, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.noticeType !== 1) { + writer.uint32(8).int32(message.noticeType); + } + if (message.field1 !== "") { + writer.uint32(18).string(message.field1); + } + if (message.field2 !== 0) { + writer.uint32(24).uint32(message.field2); + } + if (message.field3 !== 0) { + writer.uint32(32).uint32(message.field3); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadTerminalInformationResponse_TerminalNotice { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadTerminalInformationResponse_TerminalNotice(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.noticeType = reader.int32() as any; + break; + case 2: + message.field1 = reader.string(); + break; + case 3: + message.field2 = reader.uint32(); + break; + case 4: + message.field3 = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadTerminalInformationResponse_TerminalNotice { + return { + noticeType: isSet(object.noticeType) + ? noticeEntryFromJSON(object.noticeType) + : 1, + field1: isSet(object.field1) ? String(object.field1) : "", + field2: isSet(object.field2) ? Number(object.field2) : 0, + field3: isSet(object.field3) ? Number(object.field3) : 0, + }; + }, + + toJSON(message: LoadTerminalInformationResponse_TerminalNotice): unknown { + const obj: any = {}; + message.noticeType !== undefined && + (obj.noticeType = noticeEntryToJSON(message.noticeType)); + message.field1 !== undefined && (obj.field1 = message.field1); + message.field2 !== undefined && (obj.field2 = Math.round(message.field2)); + message.field3 !== undefined && (obj.field3 = Math.round(message.field3)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): LoadTerminalInformationResponse_TerminalNotice { + const message = createBaseLoadTerminalInformationResponse_TerminalNotice(); + message.noticeType = object.noticeType ?? 1; + message.field1 = object.field1 ?? ""; + message.field2 = object.field2 ?? 0; + message.field3 = object.field3 ?? 0; + return message; + }, +}; + +function createBaseCreateUserRequest(): CreateUserRequest { + return { + banapassportAmId: 0, + cardChipId: "", + accessCode: "", + cardTypeCode: 0, + cardRegionCode: 0, + device: 0, + timestamp: 0, + }; +} + +export const CreateUserRequest = { + encode( + message: CreateUserRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.banapassportAmId !== 0) { + writer.uint32(8).uint32(message.banapassportAmId); + } + if (message.cardChipId !== "") { + writer.uint32(18).string(message.cardChipId); + } + if (message.accessCode !== "") { + writer.uint32(26).string(message.accessCode); + } + if (message.cardTypeCode !== 0) { + writer.uint32(32).uint32(message.cardTypeCode); + } + if (message.cardRegionCode !== 0) { + writer.uint32(40).uint32(message.cardRegionCode); + } + if (message.device !== 0) { + writer.uint32(48).int32(message.device); + } + if (message.timestamp !== 0) { + writer.uint32(56).uint32(message.timestamp); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CreateUserRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCreateUserRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.banapassportAmId = reader.uint32(); + break; + case 2: + message.cardChipId = reader.string(); + break; + case 3: + message.accessCode = reader.string(); + break; + case 4: + message.cardTypeCode = reader.uint32(); + break; + case 5: + message.cardRegionCode = reader.uint32(); + break; + case 6: + message.device = reader.int32() as any; + break; + case 7: + message.timestamp = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CreateUserRequest { + return { + banapassportAmId: isSet(object.banapassportAmId) + ? Number(object.banapassportAmId) + : 0, + cardChipId: isSet(object.cardChipId) ? String(object.cardChipId) : "", + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + cardTypeCode: isSet(object.cardTypeCode) + ? Number(object.cardTypeCode) + : 0, + cardRegionCode: isSet(object.cardRegionCode) + ? Number(object.cardRegionCode) + : 0, + device: isSet(object.device) ? deviceTypeFromJSON(object.device) : 0, + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + }; + }, + + toJSON(message: CreateUserRequest): unknown { + const obj: any = {}; + message.banapassportAmId !== undefined && + (obj.banapassportAmId = Math.round(message.banapassportAmId)); + message.cardChipId !== undefined && (obj.cardChipId = message.cardChipId); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.cardTypeCode !== undefined && + (obj.cardTypeCode = Math.round(message.cardTypeCode)); + message.cardRegionCode !== undefined && + (obj.cardRegionCode = Math.round(message.cardRegionCode)); + message.device !== undefined && + (obj.device = deviceTypeToJSON(message.device)); + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CreateUserRequest { + const message = createBaseCreateUserRequest(); + message.banapassportAmId = object.banapassportAmId ?? 0; + message.cardChipId = object.cardChipId ?? ""; + message.accessCode = object.accessCode ?? ""; + message.cardTypeCode = object.cardTypeCode ?? 0; + message.cardRegionCode = object.cardRegionCode ?? 0; + message.device = object.device ?? 0; + message.timestamp = object.timestamp ?? 0; + return message; + }, +}; + +function createBaseCreateUserResponse(): CreateUserResponse { + return { error: 0, accessCode: "", banapassportAmId: 0, mbid: 0, userId: 0 }; +} + +export const CreateUserResponse = { + encode( + message: CreateUserResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.accessCode !== "") { + writer.uint32(18).string(message.accessCode); + } + if (message.banapassportAmId !== 0) { + writer.uint32(24).uint32(message.banapassportAmId); + } + if (message.mbid !== 0) { + writer.uint32(32).uint32(message.mbid); + } + if (message.userId !== 0) { + writer.uint32(40).uint32(message.userId); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CreateUserResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCreateUserResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.accessCode = reader.string(); + break; + case 3: + message.banapassportAmId = reader.uint32(); + break; + case 4: + message.mbid = reader.uint32(); + break; + case 5: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CreateUserResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + banapassportAmId: isSet(object.banapassportAmId) + ? Number(object.banapassportAmId) + : 0, + mbid: isSet(object.mbid) ? Number(object.mbid) : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: CreateUserResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + message.banapassportAmId !== undefined && + (obj.banapassportAmId = Math.round(message.banapassportAmId)); + message.mbid !== undefined && (obj.mbid = Math.round(message.mbid)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CreateUserResponse { + const message = createBaseCreateUserResponse(); + message.error = object.error ?? 0; + message.accessCode = object.accessCode ?? ""; + message.banapassportAmId = object.banapassportAmId ?? 0; + message.mbid = object.mbid ?? 0; + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseAskAccessCodeRequest(): AskAccessCodeRequest { + return { cardChipId: "" }; +} + +export const AskAccessCodeRequest = { + encode( + message: AskAccessCodeRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.cardChipId !== "") { + writer.uint32(10).string(message.cardChipId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): AskAccessCodeRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAskAccessCodeRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.cardChipId = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): AskAccessCodeRequest { + return { + cardChipId: isSet(object.cardChipId) ? String(object.cardChipId) : "", + }; + }, + + toJSON(message: AskAccessCodeRequest): unknown { + const obj: any = {}; + message.cardChipId !== undefined && (obj.cardChipId = message.cardChipId); + return obj; + }, + + fromPartial, I>>( + object: I + ): AskAccessCodeRequest { + const message = createBaseAskAccessCodeRequest(); + message.cardChipId = object.cardChipId ?? ""; + return message; + }, +}; + +function createBaseAskAccessCodeResponse(): AskAccessCodeResponse { + return { error: 0, accessCode: "" }; +} + +export const AskAccessCodeResponse = { + encode( + message: AskAccessCodeResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.accessCode !== "") { + writer.uint32(18).string(message.accessCode); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): AskAccessCodeResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAskAccessCodeResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.accessCode = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): AskAccessCodeResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + accessCode: isSet(object.accessCode) ? String(object.accessCode) : "", + }; + }, + + toJSON(message: AskAccessCodeResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.accessCode !== undefined && (obj.accessCode = message.accessCode); + return obj; + }, + + fromPartial, I>>( + object: I + ): AskAccessCodeResponse { + const message = createBaseAskAccessCodeResponse(); + message.error = object.error ?? 0; + message.accessCode = object.accessCode ?? ""; + return message; + }, +}; + +function createBaseRegisterOpponentGhostRequest(): RegisterOpponentGhostRequest { + return { carId: 0, specialGhostId: 0 }; +} + +export const RegisterOpponentGhostRequest = { + encode( + message: RegisterOpponentGhostRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.specialGhostId !== 0) { + writer.uint32(16).uint32(message.specialGhostId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterOpponentGhostRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterOpponentGhostRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.specialGhostId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterOpponentGhostRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + specialGhostId: isSet(object.specialGhostId) + ? Number(object.specialGhostId) + : 0, + }; + }, + + toJSON(message: RegisterOpponentGhostRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.specialGhostId !== undefined && + (obj.specialGhostId = Math.round(message.specialGhostId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterOpponentGhostRequest { + const message = createBaseRegisterOpponentGhostRequest(); + message.carId = object.carId ?? 0; + message.specialGhostId = object.specialGhostId ?? 0; + return message; + }, +}; + +function createBaseRegisterOpponentGhostResponse(): RegisterOpponentGhostResponse { + return { error: 0 }; +} + +export const RegisterOpponentGhostResponse = { + encode( + message: RegisterOpponentGhostResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): RegisterOpponentGhostResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRegisterOpponentGhostResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): RegisterOpponentGhostResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: RegisterOpponentGhostResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): RegisterOpponentGhostResponse { + const message = createBaseRegisterOpponentGhostResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseGrantCarRightRequest(): GrantCarRightRequest { + return { userId: 0, targetUserId: 0, timestamp: 0 }; +} + +export const GrantCarRightRequest = { + encode( + message: GrantCarRightRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + if (message.targetUserId !== 0) { + writer.uint32(16).uint32(message.targetUserId); + } + if (message.timestamp !== 0) { + writer.uint32(24).uint32(message.timestamp); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): GrantCarRightRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGrantCarRightRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.targetUserId = reader.uint32(); + break; + case 3: + message.timestamp = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GrantCarRightRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + targetUserId: isSet(object.targetUserId) + ? Number(object.targetUserId) + : 0, + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + }; + }, + + toJSON(message: GrantCarRightRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.targetUserId !== undefined && + (obj.targetUserId = Math.round(message.targetUserId)); + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GrantCarRightRequest { + const message = createBaseGrantCarRightRequest(); + message.userId = object.userId ?? 0; + message.targetUserId = object.targetUserId ?? 0; + message.timestamp = object.timestamp ?? 0; + return message; + }, +}; + +function createBaseGrantCarRightResponse(): GrantCarRightResponse { + return { error: 0 }; +} + +export const GrantCarRightResponse = { + encode( + message: GrantCarRightResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): GrantCarRightResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGrantCarRightResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GrantCarRightResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: GrantCarRightResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GrantCarRightResponse { + const message = createBaseGrantCarRightResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseLoadGhostCompetitionRankingRequest(): LoadGhostCompetitionRankingRequest { + return { carId: 0, competitionId: 0 }; +} + +export const LoadGhostCompetitionRankingRequest = { + encode( + message: LoadGhostCompetitionRankingRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.competitionId !== 0) { + writer.uint32(16).uint32(message.competitionId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostCompetitionRankingRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostCompetitionRankingRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.competitionId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostCompetitionRankingRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + competitionId: isSet(object.competitionId) + ? Number(object.competitionId) + : 0, + }; + }, + + toJSON(message: LoadGhostCompetitionRankingRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.competitionId !== undefined && + (obj.competitionId = Math.round(message.competitionId)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGhostCompetitionRankingRequest { + const message = createBaseLoadGhostCompetitionRankingRequest(); + message.carId = object.carId ?? 0; + message.competitionId = object.competitionId ?? 0; + return message; + }, +}; + +function createBaseLoadGhostCompetitionRankingResponse(): LoadGhostCompetitionRankingResponse { + return { + error: 0, + periodId: 0, + numOfParticipants: 0, + competitionSchedule: undefined, + ownRecord: undefined, + topRecords: [], + }; +} + +export const LoadGhostCompetitionRankingResponse = { + encode( + message: LoadGhostCompetitionRankingResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.periodId !== 0) { + writer.uint32(16).uint32(message.periodId); + } + if (message.numOfParticipants !== 0) { + writer.uint32(24).uint32(message.numOfParticipants); + } + if (message.competitionSchedule !== undefined) { + GhostCompetitionSchedule.encode( + message.competitionSchedule, + writer.uint32(34).fork() + ).ldelim(); + } + if (message.ownRecord !== undefined) { + LoadGhostCompetitionRankingResponse_Entry.encode( + message.ownRecord, + writer.uint32(42).fork() + ).ldelim(); + } + for (const v of message.topRecords) { + LoadGhostCompetitionRankingResponse_Entry.encode( + v!, + writer.uint32(50).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostCompetitionRankingResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostCompetitionRankingResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.periodId = reader.uint32(); + break; + case 3: + message.numOfParticipants = reader.uint32(); + break; + case 4: + message.competitionSchedule = GhostCompetitionSchedule.decode( + reader, + reader.uint32() + ); + break; + case 5: + message.ownRecord = LoadGhostCompetitionRankingResponse_Entry.decode( + reader, + reader.uint32() + ); + break; + case 6: + message.topRecords.push( + LoadGhostCompetitionRankingResponse_Entry.decode( + reader, + reader.uint32() + ) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostCompetitionRankingResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + periodId: isSet(object.periodId) ? Number(object.periodId) : 0, + numOfParticipants: isSet(object.numOfParticipants) + ? Number(object.numOfParticipants) + : 0, + competitionSchedule: isSet(object.competitionSchedule) + ? GhostCompetitionSchedule.fromJSON(object.competitionSchedule) + : undefined, + ownRecord: isSet(object.ownRecord) + ? LoadGhostCompetitionRankingResponse_Entry.fromJSON(object.ownRecord) + : undefined, + topRecords: Array.isArray(object?.topRecords) + ? object.topRecords.map((e: any) => + LoadGhostCompetitionRankingResponse_Entry.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: LoadGhostCompetitionRankingResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.periodId !== undefined && + (obj.periodId = Math.round(message.periodId)); + message.numOfParticipants !== undefined && + (obj.numOfParticipants = Math.round(message.numOfParticipants)); + message.competitionSchedule !== undefined && + (obj.competitionSchedule = message.competitionSchedule + ? GhostCompetitionSchedule.toJSON(message.competitionSchedule) + : undefined); + message.ownRecord !== undefined && + (obj.ownRecord = message.ownRecord + ? LoadGhostCompetitionRankingResponse_Entry.toJSON(message.ownRecord) + : undefined); + if (message.topRecords) { + obj.topRecords = message.topRecords.map((e) => + e ? LoadGhostCompetitionRankingResponse_Entry.toJSON(e) : undefined + ); + } else { + obj.topRecords = []; + } + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGhostCompetitionRankingResponse { + const message = createBaseLoadGhostCompetitionRankingResponse(); + message.error = object.error ?? 0; + message.periodId = object.periodId ?? 0; + message.numOfParticipants = object.numOfParticipants ?? 0; + message.competitionSchedule = + object.competitionSchedule !== undefined && + object.competitionSchedule !== null + ? GhostCompetitionSchedule.fromPartial(object.competitionSchedule) + : undefined; + message.ownRecord = + object.ownRecord !== undefined && object.ownRecord !== null + ? LoadGhostCompetitionRankingResponse_Entry.fromPartial( + object.ownRecord + ) + : undefined; + message.topRecords = + object.topRecords?.map((e) => + LoadGhostCompetitionRankingResponse_Entry.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseLoadGhostCompetitionRankingResponse_Entry(): LoadGhostCompetitionRankingResponse_Entry { + return { + rank: 0, + result: 0, + carId: 0, + name: "", + regionId: 0, + model: 0, + visualModel: 0, + defaultColor: 0, + title: "", + level: 0, + windowStickerString: "", + playedShopName: "", + playedAt: 0, + }; +} + +export const LoadGhostCompetitionRankingResponse_Entry = { + encode( + message: LoadGhostCompetitionRankingResponse_Entry, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.rank !== 0) { + writer.uint32(8).uint32(message.rank); + } + if (message.result !== 0) { + writer.uint32(16).sint32(message.result); + } + if (message.carId !== 0) { + writer.uint32(24).uint32(message.carId); + } + if (message.name !== "") { + writer.uint32(34).string(message.name); + } + if (message.regionId !== 0) { + writer.uint32(40).uint32(message.regionId); + } + if (message.model !== 0) { + writer.uint32(48).uint32(message.model); + } + if (message.visualModel !== 0) { + writer.uint32(56).uint32(message.visualModel); + } + if (message.defaultColor !== 0) { + writer.uint32(64).uint32(message.defaultColor); + } + if (message.title !== "") { + writer.uint32(82).string(message.title); + } + if (message.level !== 0) { + writer.uint32(88).uint32(message.level); + } + if (message.windowStickerString !== "") { + writer.uint32(98).string(message.windowStickerString); + } + if (message.playedShopName !== "") { + writer.uint32(106).string(message.playedShopName); + } + if (message.playedAt !== 0) { + writer.uint32(112).uint32(message.playedAt); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostCompetitionRankingResponse_Entry { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostCompetitionRankingResponse_Entry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.rank = reader.uint32(); + break; + case 2: + message.result = reader.sint32(); + break; + case 3: + message.carId = reader.uint32(); + break; + case 4: + message.name = reader.string(); + break; + case 5: + message.regionId = reader.uint32(); + break; + case 6: + message.model = reader.uint32(); + break; + case 7: + message.visualModel = reader.uint32(); + break; + case 8: + message.defaultColor = reader.uint32(); + break; + case 10: + message.title = reader.string(); + break; + case 11: + message.level = reader.uint32(); + break; + case 12: + message.windowStickerString = reader.string(); + break; + case 13: + message.playedShopName = reader.string(); + break; + case 14: + message.playedAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostCompetitionRankingResponse_Entry { + return { + rank: isSet(object.rank) ? Number(object.rank) : 0, + result: isSet(object.result) ? Number(object.result) : 0, + carId: isSet(object.carId) ? Number(object.carId) : 0, + name: isSet(object.name) ? String(object.name) : "", + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + model: isSet(object.model) ? Number(object.model) : 0, + visualModel: isSet(object.visualModel) ? Number(object.visualModel) : 0, + defaultColor: isSet(object.defaultColor) + ? Number(object.defaultColor) + : 0, + title: isSet(object.title) ? String(object.title) : "", + level: isSet(object.level) ? Number(object.level) : 0, + windowStickerString: isSet(object.windowStickerString) + ? String(object.windowStickerString) + : "", + playedShopName: isSet(object.playedShopName) + ? String(object.playedShopName) + : "", + playedAt: isSet(object.playedAt) ? Number(object.playedAt) : 0, + }; + }, + + toJSON(message: LoadGhostCompetitionRankingResponse_Entry): unknown { + const obj: any = {}; + message.rank !== undefined && (obj.rank = Math.round(message.rank)); + message.result !== undefined && (obj.result = Math.round(message.result)); + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.name !== undefined && (obj.name = message.name); + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + message.model !== undefined && (obj.model = Math.round(message.model)); + message.visualModel !== undefined && + (obj.visualModel = Math.round(message.visualModel)); + message.defaultColor !== undefined && + (obj.defaultColor = Math.round(message.defaultColor)); + message.title !== undefined && (obj.title = message.title); + message.level !== undefined && (obj.level = Math.round(message.level)); + message.windowStickerString !== undefined && + (obj.windowStickerString = message.windowStickerString); + message.playedShopName !== undefined && + (obj.playedShopName = message.playedShopName); + message.playedAt !== undefined && + (obj.playedAt = Math.round(message.playedAt)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGhostCompetitionRankingResponse_Entry { + const message = createBaseLoadGhostCompetitionRankingResponse_Entry(); + message.rank = object.rank ?? 0; + message.result = object.result ?? 0; + message.carId = object.carId ?? 0; + message.name = object.name ?? ""; + message.regionId = object.regionId ?? 0; + message.model = object.model ?? 0; + message.visualModel = object.visualModel ?? 0; + message.defaultColor = object.defaultColor ?? 0; + message.title = object.title ?? ""; + message.level = object.level ?? 0; + message.windowStickerString = object.windowStickerString ?? ""; + message.playedShopName = object.playedShopName ?? ""; + message.playedAt = object.playedAt ?? 0; + return message; + }, +}; + +function createBaseLoadUnreceivedUserItemsRequest(): LoadUnreceivedUserItemsRequest { + return { userId: 0 }; +} + +export const LoadUnreceivedUserItemsRequest = { + encode( + message: LoadUnreceivedUserItemsRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadUnreceivedUserItemsRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadUnreceivedUserItemsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadUnreceivedUserItemsRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: LoadUnreceivedUserItemsRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadUnreceivedUserItemsRequest { + const message = createBaseLoadUnreceivedUserItemsRequest(); + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseLoadUnreceivedUserItemsResponse(): LoadUnreceivedUserItemsResponse { + return { error: 0, ownedUserItems: [] }; +} + +export const LoadUnreceivedUserItemsResponse = { + encode( + message: LoadUnreceivedUserItemsResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.ownedUserItems) { + UserItem.encode(v!, writer.uint32(58).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadUnreceivedUserItemsResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadUnreceivedUserItemsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 7: + message.ownedUserItems.push(UserItem.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadUnreceivedUserItemsResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + ownedUserItems: Array.isArray(object?.ownedUserItems) + ? object.ownedUserItems.map((e: any) => UserItem.fromJSON(e)) + : [], + }; + }, + + toJSON(message: LoadUnreceivedUserItemsResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.ownedUserItems) { + obj.ownedUserItems = message.ownedUserItems.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.ownedUserItems = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadUnreceivedUserItemsResponse { + const message = createBaseLoadUnreceivedUserItemsResponse(); + message.error = object.error ?? 0; + message.ownedUserItems = + object.ownedUserItems?.map((e) => UserItem.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseLoadBookmarksRequest(): LoadBookmarksRequest { + return { userId: 0 }; +} + +export const LoadBookmarksRequest = { + encode( + message: LoadBookmarksRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadBookmarksRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadBookmarksRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadBookmarksRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: LoadBookmarksRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadBookmarksRequest { + const message = createBaseLoadBookmarksRequest(); + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseLoadBookmarksResponse(): LoadBookmarksResponse { + return { error: 0, cars: [] }; +} + +export const LoadBookmarksResponse = { + encode( + message: LoadBookmarksResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.cars) { + Car.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadBookmarksResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadBookmarksResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.cars.push(Car.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadBookmarksResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + cars: Array.isArray(object?.cars) + ? object.cars.map((e: any) => Car.fromJSON(e)) + : [], + }; + }, + + toJSON(message: LoadBookmarksResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.cars) { + obj.cars = message.cars.map((e) => (e ? Car.toJSON(e) : undefined)); + } else { + obj.cars = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadBookmarksResponse { + const message = createBaseLoadBookmarksResponse(); + message.error = object.error ?? 0; + message.cars = object.cars?.map((e) => Car.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseSaveBookmarksRequest(): SaveBookmarksRequest { + return { userId: 0, cars: [] }; +} + +export const SaveBookmarksRequest = { + encode( + message: SaveBookmarksRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + writer.uint32(18).fork(); + for (const v of message.cars) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveBookmarksRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveBookmarksRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.cars.push(reader.uint32()); + } + } else { + message.cars.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveBookmarksRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + cars: Array.isArray(object?.cars) + ? object.cars.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: SaveBookmarksRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + if (message.cars) { + obj.cars = message.cars.map((e) => Math.round(e)); + } else { + obj.cars = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveBookmarksRequest { + const message = createBaseSaveBookmarksRequest(); + message.userId = object.userId ?? 0; + message.cars = object.cars?.map((e) => e) || []; + return message; + }, +}; + +function createBaseSaveBookmarksResponse(): SaveBookmarksResponse { + return { error: 0 }; +} + +export const SaveBookmarksResponse = { + encode( + message: SaveBookmarksResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveBookmarksResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveBookmarksResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveBookmarksResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: SaveBookmarksResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveBookmarksResponse { + const message = createBaseSaveBookmarksResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseStartTransferRequest(): StartTransferRequest { + return { banapassportAmId: 0 }; +} + +export const StartTransferRequest = { + encode( + message: StartTransferRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.banapassportAmId !== 0) { + writer.uint32(8).uint32(message.banapassportAmId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): StartTransferRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStartTransferRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.banapassportAmId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): StartTransferRequest { + return { + banapassportAmId: isSet(object.banapassportAmId) + ? Number(object.banapassportAmId) + : 0, + }; + }, + + toJSON(message: StartTransferRequest): unknown { + const obj: any = {}; + message.banapassportAmId !== undefined && + (obj.banapassportAmId = Math.round(message.banapassportAmId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): StartTransferRequest { + const message = createBaseStartTransferRequest(); + message.banapassportAmId = object.banapassportAmId ?? 0; + return message; + }, +}; + +function createBaseStartTransferResponse(): StartTransferResponse { + return { error: 0, userId: 0, pollingInterval: 0 }; +} + +export const StartTransferResponse = { + encode( + message: StartTransferResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.userId !== 0) { + writer.uint32(16).uint32(message.userId); + } + if (message.pollingInterval !== 0) { + writer.uint32(24).uint32(message.pollingInterval); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): StartTransferResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStartTransferResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.userId = reader.uint32(); + break; + case 3: + message.pollingInterval = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): StartTransferResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + pollingInterval: isSet(object.pollingInterval) + ? Number(object.pollingInterval) + : 0, + }; + }, + + toJSON(message: StartTransferResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.pollingInterval !== undefined && + (obj.pollingInterval = Math.round(message.pollingInterval)); + return obj; + }, + + fromPartial, I>>( + object: I + ): StartTransferResponse { + const message = createBaseStartTransferResponse(); + message.error = object.error ?? 0; + message.userId = object.userId ?? 0; + message.pollingInterval = object.pollingInterval ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest(): SaveScreenshotRequest { + return { + carId: 0, + timestamp: 0, + playedAt: 0, + transparent: false, + imageType: 1, + image: Buffer.alloc(0), + ghostMetadata: undefined, + versusMetadata: undefined, + terminalMetadata: undefined, + acquiringVsStarMetadata: undefined, + acquiringAuraMotifMetadata: undefined, + ghostRegionMapMetadata: undefined, + acquiringCrownMetadata: undefined, + competitionResultMetadata: undefined, + timeAttackResultMetadata: undefined, + levelUpMetadata: undefined, + }; +} + +export const SaveScreenshotRequest = { + encode( + message: SaveScreenshotRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.timestamp !== 0) { + writer.uint32(16).uint32(message.timestamp); + } + if (message.playedAt !== 0) { + writer.uint32(72).uint32(message.playedAt); + } + if (message.transparent === true) { + writer.uint32(64).bool(message.transparent); + } + if (message.imageType !== 1) { + writer.uint32(24).int32(message.imageType); + } + if (message.image.length !== 0) { + writer.uint32(34).bytes(message.image); + } + if (message.ghostMetadata !== undefined) { + SaveScreenshotRequest_GhostBattleMetadata.encode( + message.ghostMetadata, + writer.uint32(42).fork() + ).ldelim(); + } + if (message.versusMetadata !== undefined) { + SaveScreenshotRequest_VersusBattleMetadata.encode( + message.versusMetadata, + writer.uint32(50).fork() + ).ldelim(); + } + if (message.terminalMetadata !== undefined) { + SaveScreenshotRequest_TerminalMetadata.encode( + message.terminalMetadata, + writer.uint32(58).fork() + ).ldelim(); + } + if (message.acquiringVsStarMetadata !== undefined) { + SaveScreenshotRequest_AcquiringVersusStarMetadata.encode( + message.acquiringVsStarMetadata, + writer.uint32(82).fork() + ).ldelim(); + } + if (message.acquiringAuraMotifMetadata !== undefined) { + SaveScreenshotRequest_AcquiringAuraMotifMetadata.encode( + message.acquiringAuraMotifMetadata, + writer.uint32(90).fork() + ).ldelim(); + } + if (message.ghostRegionMapMetadata !== undefined) { + SaveScreenshotRequest_GhostRegionMapMetadata.encode( + message.ghostRegionMapMetadata, + writer.uint32(98).fork() + ).ldelim(); + } + if (message.acquiringCrownMetadata !== undefined) { + SaveScreenshotRequest_AcquiringCrownMetadata.encode( + message.acquiringCrownMetadata, + writer.uint32(106).fork() + ).ldelim(); + } + if (message.competitionResultMetadata !== undefined) { + SaveScreenshotRequest_GhostCompetitionResultMetadata.encode( + message.competitionResultMetadata, + writer.uint32(114).fork() + ).ldelim(); + } + if (message.timeAttackResultMetadata !== undefined) { + SaveScreenshotRequest_TimeAttackResultMetadata.encode( + message.timeAttackResultMetadata, + writer.uint32(122).fork() + ).ldelim(); + } + if (message.levelUpMetadata !== undefined) { + SaveScreenshotRequest_LevelUpMetadata.encode( + message.levelUpMetadata, + writer.uint32(130).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.timestamp = reader.uint32(); + break; + case 9: + message.playedAt = reader.uint32(); + break; + case 8: + message.transparent = reader.bool(); + break; + case 3: + message.imageType = reader.int32() as any; + break; + case 4: + message.image = reader.bytes() as Buffer; + break; + case 5: + message.ghostMetadata = + SaveScreenshotRequest_GhostBattleMetadata.decode( + reader, + reader.uint32() + ); + break; + case 6: + message.versusMetadata = + SaveScreenshotRequest_VersusBattleMetadata.decode( + reader, + reader.uint32() + ); + break; + case 7: + message.terminalMetadata = + SaveScreenshotRequest_TerminalMetadata.decode( + reader, + reader.uint32() + ); + break; + case 10: + message.acquiringVsStarMetadata = + SaveScreenshotRequest_AcquiringVersusStarMetadata.decode( + reader, + reader.uint32() + ); + break; + case 11: + message.acquiringAuraMotifMetadata = + SaveScreenshotRequest_AcquiringAuraMotifMetadata.decode( + reader, + reader.uint32() + ); + break; + case 12: + message.ghostRegionMapMetadata = + SaveScreenshotRequest_GhostRegionMapMetadata.decode( + reader, + reader.uint32() + ); + break; + case 13: + message.acquiringCrownMetadata = + SaveScreenshotRequest_AcquiringCrownMetadata.decode( + reader, + reader.uint32() + ); + break; + case 14: + message.competitionResultMetadata = + SaveScreenshotRequest_GhostCompetitionResultMetadata.decode( + reader, + reader.uint32() + ); + break; + case 15: + message.timeAttackResultMetadata = + SaveScreenshotRequest_TimeAttackResultMetadata.decode( + reader, + reader.uint32() + ); + break; + case 16: + message.levelUpMetadata = + SaveScreenshotRequest_LevelUpMetadata.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + playedAt: isSet(object.playedAt) ? Number(object.playedAt) : 0, + transparent: isSet(object.transparent) + ? Boolean(object.transparent) + : false, + imageType: isSet(object.imageType) + ? screenshotTypeFromJSON(object.imageType) + : 1, + image: isSet(object.image) + ? Buffer.from(bytesFromBase64(object.image)) + : Buffer.alloc(0), + ghostMetadata: isSet(object.ghostMetadata) + ? SaveScreenshotRequest_GhostBattleMetadata.fromJSON( + object.ghostMetadata + ) + : undefined, + versusMetadata: isSet(object.versusMetadata) + ? SaveScreenshotRequest_VersusBattleMetadata.fromJSON( + object.versusMetadata + ) + : undefined, + terminalMetadata: isSet(object.terminalMetadata) + ? SaveScreenshotRequest_TerminalMetadata.fromJSON( + object.terminalMetadata + ) + : undefined, + acquiringVsStarMetadata: isSet(object.acquiringVsStarMetadata) + ? SaveScreenshotRequest_AcquiringVersusStarMetadata.fromJSON( + object.acquiringVsStarMetadata + ) + : undefined, + acquiringAuraMotifMetadata: isSet(object.acquiringAuraMotifMetadata) + ? SaveScreenshotRequest_AcquiringAuraMotifMetadata.fromJSON( + object.acquiringAuraMotifMetadata + ) + : undefined, + ghostRegionMapMetadata: isSet(object.ghostRegionMapMetadata) + ? SaveScreenshotRequest_GhostRegionMapMetadata.fromJSON( + object.ghostRegionMapMetadata + ) + : undefined, + acquiringCrownMetadata: isSet(object.acquiringCrownMetadata) + ? SaveScreenshotRequest_AcquiringCrownMetadata.fromJSON( + object.acquiringCrownMetadata + ) + : undefined, + competitionResultMetadata: isSet(object.competitionResultMetadata) + ? SaveScreenshotRequest_GhostCompetitionResultMetadata.fromJSON( + object.competitionResultMetadata + ) + : undefined, + timeAttackResultMetadata: isSet(object.timeAttackResultMetadata) + ? SaveScreenshotRequest_TimeAttackResultMetadata.fromJSON( + object.timeAttackResultMetadata + ) + : undefined, + levelUpMetadata: isSet(object.levelUpMetadata) + ? SaveScreenshotRequest_LevelUpMetadata.fromJSON(object.levelUpMetadata) + : undefined, + }; + }, + + toJSON(message: SaveScreenshotRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + message.playedAt !== undefined && + (obj.playedAt = Math.round(message.playedAt)); + message.transparent !== undefined && + (obj.transparent = message.transparent); + message.imageType !== undefined && + (obj.imageType = screenshotTypeToJSON(message.imageType)); + message.image !== undefined && + (obj.image = base64FromBytes( + message.image !== undefined ? message.image : Buffer.alloc(0) + )); + message.ghostMetadata !== undefined && + (obj.ghostMetadata = message.ghostMetadata + ? SaveScreenshotRequest_GhostBattleMetadata.toJSON( + message.ghostMetadata + ) + : undefined); + message.versusMetadata !== undefined && + (obj.versusMetadata = message.versusMetadata + ? SaveScreenshotRequest_VersusBattleMetadata.toJSON( + message.versusMetadata + ) + : undefined); + message.terminalMetadata !== undefined && + (obj.terminalMetadata = message.terminalMetadata + ? SaveScreenshotRequest_TerminalMetadata.toJSON( + message.terminalMetadata + ) + : undefined); + message.acquiringVsStarMetadata !== undefined && + (obj.acquiringVsStarMetadata = message.acquiringVsStarMetadata + ? SaveScreenshotRequest_AcquiringVersusStarMetadata.toJSON( + message.acquiringVsStarMetadata + ) + : undefined); + message.acquiringAuraMotifMetadata !== undefined && + (obj.acquiringAuraMotifMetadata = message.acquiringAuraMotifMetadata + ? SaveScreenshotRequest_AcquiringAuraMotifMetadata.toJSON( + message.acquiringAuraMotifMetadata + ) + : undefined); + message.ghostRegionMapMetadata !== undefined && + (obj.ghostRegionMapMetadata = message.ghostRegionMapMetadata + ? SaveScreenshotRequest_GhostRegionMapMetadata.toJSON( + message.ghostRegionMapMetadata + ) + : undefined); + message.acquiringCrownMetadata !== undefined && + (obj.acquiringCrownMetadata = message.acquiringCrownMetadata + ? SaveScreenshotRequest_AcquiringCrownMetadata.toJSON( + message.acquiringCrownMetadata + ) + : undefined); + message.competitionResultMetadata !== undefined && + (obj.competitionResultMetadata = message.competitionResultMetadata + ? SaveScreenshotRequest_GhostCompetitionResultMetadata.toJSON( + message.competitionResultMetadata + ) + : undefined); + message.timeAttackResultMetadata !== undefined && + (obj.timeAttackResultMetadata = message.timeAttackResultMetadata + ? SaveScreenshotRequest_TimeAttackResultMetadata.toJSON( + message.timeAttackResultMetadata + ) + : undefined); + message.levelUpMetadata !== undefined && + (obj.levelUpMetadata = message.levelUpMetadata + ? SaveScreenshotRequest_LevelUpMetadata.toJSON(message.levelUpMetadata) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveScreenshotRequest { + const message = createBaseSaveScreenshotRequest(); + message.carId = object.carId ?? 0; + message.timestamp = object.timestamp ?? 0; + message.playedAt = object.playedAt ?? 0; + message.transparent = object.transparent ?? false; + message.imageType = object.imageType ?? 1; + message.image = object.image ?? Buffer.alloc(0); + message.ghostMetadata = + object.ghostMetadata !== undefined && object.ghostMetadata !== null + ? SaveScreenshotRequest_GhostBattleMetadata.fromPartial( + object.ghostMetadata + ) + : undefined; + message.versusMetadata = + object.versusMetadata !== undefined && object.versusMetadata !== null + ? SaveScreenshotRequest_VersusBattleMetadata.fromPartial( + object.versusMetadata + ) + : undefined; + message.terminalMetadata = + object.terminalMetadata !== undefined && object.terminalMetadata !== null + ? SaveScreenshotRequest_TerminalMetadata.fromPartial( + object.terminalMetadata + ) + : undefined; + message.acquiringVsStarMetadata = + object.acquiringVsStarMetadata !== undefined && + object.acquiringVsStarMetadata !== null + ? SaveScreenshotRequest_AcquiringVersusStarMetadata.fromPartial( + object.acquiringVsStarMetadata + ) + : undefined; + message.acquiringAuraMotifMetadata = + object.acquiringAuraMotifMetadata !== undefined && + object.acquiringAuraMotifMetadata !== null + ? SaveScreenshotRequest_AcquiringAuraMotifMetadata.fromPartial( + object.acquiringAuraMotifMetadata + ) + : undefined; + message.ghostRegionMapMetadata = + object.ghostRegionMapMetadata !== undefined && + object.ghostRegionMapMetadata !== null + ? SaveScreenshotRequest_GhostRegionMapMetadata.fromPartial( + object.ghostRegionMapMetadata + ) + : undefined; + message.acquiringCrownMetadata = + object.acquiringCrownMetadata !== undefined && + object.acquiringCrownMetadata !== null + ? SaveScreenshotRequest_AcquiringCrownMetadata.fromPartial( + object.acquiringCrownMetadata + ) + : undefined; + message.competitionResultMetadata = + object.competitionResultMetadata !== undefined && + object.competitionResultMetadata !== null + ? SaveScreenshotRequest_GhostCompetitionResultMetadata.fromPartial( + object.competitionResultMetadata + ) + : undefined; + message.timeAttackResultMetadata = + object.timeAttackResultMetadata !== undefined && + object.timeAttackResultMetadata !== null + ? SaveScreenshotRequest_TimeAttackResultMetadata.fromPartial( + object.timeAttackResultMetadata + ) + : undefined; + message.levelUpMetadata = + object.levelUpMetadata !== undefined && object.levelUpMetadata !== null + ? SaveScreenshotRequest_LevelUpMetadata.fromPartial( + object.levelUpMetadata + ) + : undefined; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_GhostBattleMetadata(): SaveScreenshotRequest_GhostBattleMetadata { + return { + tunePower: 0, + tuneHandling: 0, + area: 0, + stampReturnCount: 0, + opponents: [], + }; +} + +export const SaveScreenshotRequest_GhostBattleMetadata = { + encode( + message: SaveScreenshotRequest_GhostBattleMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.area !== 0) { + writer.uint32(24).uint32(message.area); + } + if (message.stampReturnCount !== 0) { + writer.uint32(32).uint32(message.stampReturnCount); + } + for (const v of message.opponents) { + SaveScreenshotRequest_OpponentCar.encode( + v!, + writer.uint32(50).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_GhostBattleMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_GhostBattleMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.area = reader.uint32(); + break; + case 4: + message.stampReturnCount = reader.uint32(); + break; + case 6: + message.opponents.push( + SaveScreenshotRequest_OpponentCar.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_GhostBattleMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + area: isSet(object.area) ? Number(object.area) : 0, + stampReturnCount: isSet(object.stampReturnCount) + ? Number(object.stampReturnCount) + : 0, + opponents: Array.isArray(object?.opponents) + ? object.opponents.map((e: any) => + SaveScreenshotRequest_OpponentCar.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: SaveScreenshotRequest_GhostBattleMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.stampReturnCount !== undefined && + (obj.stampReturnCount = Math.round(message.stampReturnCount)); + if (message.opponents) { + obj.opponents = message.opponents.map((e) => + e ? SaveScreenshotRequest_OpponentCar.toJSON(e) : undefined + ); + } else { + obj.opponents = []; + } + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveScreenshotRequest_GhostBattleMetadata { + const message = createBaseSaveScreenshotRequest_GhostBattleMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.area = object.area ?? 0; + message.stampReturnCount = object.stampReturnCount ?? 0; + message.opponents = + object.opponents?.map((e) => + SaveScreenshotRequest_OpponentCar.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_VersusBattleMetadata(): SaveScreenshotRequest_VersusBattleMetadata { + return { tunePower: 0, tuneHandling: 0, area: 0, opponents: [] }; +} + +export const SaveScreenshotRequest_VersusBattleMetadata = { + encode( + message: SaveScreenshotRequest_VersusBattleMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.area !== 0) { + writer.uint32(24).uint32(message.area); + } + for (const v of message.opponents) { + SaveScreenshotRequest_OpponentCar.encode( + v!, + writer.uint32(34).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_VersusBattleMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_VersusBattleMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.area = reader.uint32(); + break; + case 4: + message.opponents.push( + SaveScreenshotRequest_OpponentCar.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_VersusBattleMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + area: isSet(object.area) ? Number(object.area) : 0, + opponents: Array.isArray(object?.opponents) + ? object.opponents.map((e: any) => + SaveScreenshotRequest_OpponentCar.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: SaveScreenshotRequest_VersusBattleMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.area !== undefined && (obj.area = Math.round(message.area)); + if (message.opponents) { + obj.opponents = message.opponents.map((e) => + e ? SaveScreenshotRequest_OpponentCar.toJSON(e) : undefined + ); + } else { + obj.opponents = []; + } + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveScreenshotRequest_VersusBattleMetadata { + const message = createBaseSaveScreenshotRequest_VersusBattleMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.area = object.area ?? 0; + message.opponents = + object.opponents?.map((e) => + SaveScreenshotRequest_OpponentCar.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_TerminalMetadata(): SaveScreenshotRequest_TerminalMetadata { + return { tunePower: 0, tuneHandling: 0, name: "", title: "", level: 0 }; +} + +export const SaveScreenshotRequest_TerminalMetadata = { + encode( + message: SaveScreenshotRequest_TerminalMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.name !== "") { + writer.uint32(26).string(message.name); + } + if (message.title !== "") { + writer.uint32(34).string(message.title); + } + if (message.level !== 0) { + writer.uint32(40).uint32(message.level); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_TerminalMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_TerminalMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.name = reader.string(); + break; + case 4: + message.title = reader.string(); + break; + case 5: + message.level = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_TerminalMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + name: isSet(object.name) ? String(object.name) : "", + title: isSet(object.title) ? String(object.title) : "", + level: isSet(object.level) ? Number(object.level) : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_TerminalMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.name !== undefined && (obj.name = message.name); + message.title !== undefined && (obj.title = message.title); + message.level !== undefined && (obj.level = Math.round(message.level)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveScreenshotRequest_TerminalMetadata { + const message = createBaseSaveScreenshotRequest_TerminalMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.name = object.name ?? ""; + message.title = object.title ?? ""; + message.level = object.level ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_AcquiringVersusStarMetadata(): SaveScreenshotRequest_AcquiringVersusStarMetadata { + return { tunePower: 0, tuneHandling: 0, vsStarCount: 0 }; +} + +export const SaveScreenshotRequest_AcquiringVersusStarMetadata = { + encode( + message: SaveScreenshotRequest_AcquiringVersusStarMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.vsStarCount !== 0) { + writer.uint32(24).uint32(message.vsStarCount); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_AcquiringVersusStarMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = + createBaseSaveScreenshotRequest_AcquiringVersusStarMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.vsStarCount = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_AcquiringVersusStarMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + vsStarCount: isSet(object.vsStarCount) ? Number(object.vsStarCount) : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_AcquiringVersusStarMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.vsStarCount !== undefined && + (obj.vsStarCount = Math.round(message.vsStarCount)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveScreenshotRequest_AcquiringVersusStarMetadata { + const message = + createBaseSaveScreenshotRequest_AcquiringVersusStarMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.vsStarCount = object.vsStarCount ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_AcquiringAuraMotifMetadata(): SaveScreenshotRequest_AcquiringAuraMotifMetadata { + return { tunePower: 0, tuneHandling: 0, auraMotif: 0 }; +} + +export const SaveScreenshotRequest_AcquiringAuraMotifMetadata = { + encode( + message: SaveScreenshotRequest_AcquiringAuraMotifMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.auraMotif !== 0) { + writer.uint32(24).uint32(message.auraMotif); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_AcquiringAuraMotifMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = + createBaseSaveScreenshotRequest_AcquiringAuraMotifMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.auraMotif = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_AcquiringAuraMotifMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + auraMotif: isSet(object.auraMotif) ? Number(object.auraMotif) : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_AcquiringAuraMotifMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.auraMotif !== undefined && + (obj.auraMotif = Math.round(message.auraMotif)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveScreenshotRequest_AcquiringAuraMotifMetadata { + const message = + createBaseSaveScreenshotRequest_AcquiringAuraMotifMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.auraMotif = object.auraMotif ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_GhostRegionMapMetadata(): SaveScreenshotRequest_GhostRegionMapMetadata { + return { tunePower: 0, tuneHandling: 0, rgScore: 0, rgRegionMapScore: [] }; +} + +export const SaveScreenshotRequest_GhostRegionMapMetadata = { + encode( + message: SaveScreenshotRequest_GhostRegionMapMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.rgScore !== 0) { + writer.uint32(24).uint32(message.rgScore); + } + writer.uint32(34).fork(); + for (const v of message.rgRegionMapScore) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_GhostRegionMapMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_GhostRegionMapMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.rgScore = reader.uint32(); + break; + case 4: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.rgRegionMapScore.push(reader.uint32()); + } + } else { + message.rgRegionMapScore.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_GhostRegionMapMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + rgScore: isSet(object.rgScore) ? Number(object.rgScore) : 0, + rgRegionMapScore: Array.isArray(object?.rgRegionMapScore) + ? object.rgRegionMapScore.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: SaveScreenshotRequest_GhostRegionMapMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.rgScore !== undefined && + (obj.rgScore = Math.round(message.rgScore)); + if (message.rgRegionMapScore) { + obj.rgRegionMapScore = message.rgRegionMapScore.map((e) => Math.round(e)); + } else { + obj.rgRegionMapScore = []; + } + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveScreenshotRequest_GhostRegionMapMetadata { + const message = createBaseSaveScreenshotRequest_GhostRegionMapMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.rgScore = object.rgScore ?? 0; + message.rgRegionMapScore = object.rgRegionMapScore?.map((e) => e) || []; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_AcquiringCrownMetadata(): SaveScreenshotRequest_AcquiringCrownMetadata { + return { tunePower: 0, tuneHandling: 0, area: 0 }; +} + +export const SaveScreenshotRequest_AcquiringCrownMetadata = { + encode( + message: SaveScreenshotRequest_AcquiringCrownMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.area !== 0) { + writer.uint32(24).uint32(message.area); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_AcquiringCrownMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_AcquiringCrownMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.area = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_AcquiringCrownMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + area: isSet(object.area) ? Number(object.area) : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_AcquiringCrownMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.area !== undefined && (obj.area = Math.round(message.area)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveScreenshotRequest_AcquiringCrownMetadata { + const message = createBaseSaveScreenshotRequest_AcquiringCrownMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.area = object.area ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_GhostCompetitionResultMetadata(): SaveScreenshotRequest_GhostCompetitionResultMetadata { + return { tunePower: 0, tuneHandling: 0, rank: 0, result: 0 }; +} + +export const SaveScreenshotRequest_GhostCompetitionResultMetadata = { + encode( + message: SaveScreenshotRequest_GhostCompetitionResultMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.rank !== 0) { + writer.uint32(24).uint32(message.rank); + } + if (message.result !== 0) { + writer.uint32(32).sint32(message.result); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_GhostCompetitionResultMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = + createBaseSaveScreenshotRequest_GhostCompetitionResultMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.rank = reader.uint32(); + break; + case 4: + message.result = reader.sint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_GhostCompetitionResultMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + rank: isSet(object.rank) ? Number(object.rank) : 0, + result: isSet(object.result) ? Number(object.result) : 0, + }; + }, + + toJSON( + message: SaveScreenshotRequest_GhostCompetitionResultMetadata + ): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.rank !== undefined && (obj.rank = Math.round(message.rank)); + message.result !== undefined && (obj.result = Math.round(message.result)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveScreenshotRequest_GhostCompetitionResultMetadata { + const message = + createBaseSaveScreenshotRequest_GhostCompetitionResultMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.rank = object.rank ?? 0; + message.result = object.result ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_TimeAttackResultMetadata(): SaveScreenshotRequest_TimeAttackResultMetadata { + return { + tunePower: 0, + tuneHandling: 0, + course: 0, + wholeRank: 0, + modelRank: 0, + }; +} + +export const SaveScreenshotRequest_TimeAttackResultMetadata = { + encode( + message: SaveScreenshotRequest_TimeAttackResultMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(8).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(16).uint32(message.tuneHandling); + } + if (message.course !== 0) { + writer.uint32(24).uint32(message.course); + } + if (message.wholeRank !== 0) { + writer.uint32(32).uint32(message.wholeRank); + } + if (message.modelRank !== 0) { + writer.uint32(40).uint32(message.modelRank); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_TimeAttackResultMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_TimeAttackResultMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.tunePower = reader.uint32(); + break; + case 2: + message.tuneHandling = reader.uint32(); + break; + case 3: + message.course = reader.uint32(); + break; + case 4: + message.wholeRank = reader.uint32(); + break; + case 5: + message.modelRank = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_TimeAttackResultMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + course: isSet(object.course) ? Number(object.course) : 0, + wholeRank: isSet(object.wholeRank) ? Number(object.wholeRank) : 0, + modelRank: isSet(object.modelRank) ? Number(object.modelRank) : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_TimeAttackResultMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.course !== undefined && (obj.course = Math.round(message.course)); + message.wholeRank !== undefined && + (obj.wholeRank = Math.round(message.wholeRank)); + message.modelRank !== undefined && + (obj.modelRank = Math.round(message.modelRank)); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): SaveScreenshotRequest_TimeAttackResultMetadata { + const message = createBaseSaveScreenshotRequest_TimeAttackResultMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.course = object.course ?? 0; + message.wholeRank = object.wholeRank ?? 0; + message.modelRank = object.modelRank ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_LevelUpMetadata(): SaveScreenshotRequest_LevelUpMetadata { + return { tunePower: 0, tuneHandling: 0, level: 0 }; +} + +export const SaveScreenshotRequest_LevelUpMetadata = { + encode( + message: SaveScreenshotRequest_LevelUpMetadata, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.tunePower !== 0) { + writer.uint32(16).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(24).uint32(message.tuneHandling); + } + if (message.level !== 0) { + writer.uint32(8).uint32(message.level); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_LevelUpMetadata { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_LevelUpMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 2: + message.tunePower = reader.uint32(); + break; + case 3: + message.tuneHandling = reader.uint32(); + break; + case 1: + message.level = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_LevelUpMetadata { + return { + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + level: isSet(object.level) ? Number(object.level) : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_LevelUpMetadata): unknown { + const obj: any = {}; + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.level !== undefined && (obj.level = Math.round(message.level)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveScreenshotRequest_LevelUpMetadata { + const message = createBaseSaveScreenshotRequest_LevelUpMetadata(); + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.level = object.level ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotRequest_OpponentCar(): SaveScreenshotRequest_OpponentCar { + return { carId: 0, tunePower: 0, tuneHandling: 0 }; +} + +export const SaveScreenshotRequest_OpponentCar = { + encode( + message: SaveScreenshotRequest_OpponentCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.tunePower !== 0) { + writer.uint32(16).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(24).uint32(message.tuneHandling); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotRequest_OpponentCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotRequest_OpponentCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.tunePower = reader.uint32(); + break; + case 3: + message.tuneHandling = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotRequest_OpponentCar { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + }; + }, + + toJSON(message: SaveScreenshotRequest_OpponentCar): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): SaveScreenshotRequest_OpponentCar { + const message = createBaseSaveScreenshotRequest_OpponentCar(); + message.carId = object.carId ?? 0; + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + return message; + }, +}; + +function createBaseSaveScreenshotResponse(): SaveScreenshotResponse { + return { error: 0 }; +} + +export const SaveScreenshotResponse = { + encode( + message: SaveScreenshotResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScreenshotResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScreenshotResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScreenshotResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: SaveScreenshotResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveScreenshotResponse { + const message = createBaseSaveScreenshotResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseSubmitClientLogRequest(): SubmitClientLogRequest { + return { data: Buffer.alloc(0), modifiedAt: 0, logType: 0 }; +} + +export const SubmitClientLogRequest = { + encode( + message: SubmitClientLogRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.data.length !== 0) { + writer.uint32(10).bytes(message.data); + } + if (message.modifiedAt !== 0) { + writer.uint32(16).uint32(message.modifiedAt); + } + if (message.logType !== 0) { + writer.uint32(24).int32(message.logType); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SubmitClientLogRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSubmitClientLogRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.data = reader.bytes() as Buffer; + break; + case 2: + message.modifiedAt = reader.uint32(); + break; + case 3: + message.logType = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SubmitClientLogRequest { + return { + data: isSet(object.data) + ? Buffer.from(bytesFromBase64(object.data)) + : Buffer.alloc(0), + modifiedAt: isSet(object.modifiedAt) ? Number(object.modifiedAt) : 0, + logType: isSet(object.logType) + ? clientLogTypeFromJSON(object.logType) + : 0, + }; + }, + + toJSON(message: SubmitClientLogRequest): unknown { + const obj: any = {}; + message.data !== undefined && + (obj.data = base64FromBytes( + message.data !== undefined ? message.data : Buffer.alloc(0) + )); + message.modifiedAt !== undefined && + (obj.modifiedAt = Math.round(message.modifiedAt)); + message.logType !== undefined && + (obj.logType = clientLogTypeToJSON(message.logType)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SubmitClientLogRequest { + const message = createBaseSubmitClientLogRequest(); + message.data = object.data ?? Buffer.alloc(0); + message.modifiedAt = object.modifiedAt ?? 0; + message.logType = object.logType ?? 0; + return message; + }, +}; + +function createBaseSubmitClientLogResponse(): SubmitClientLogResponse { + return { error: 0 }; +} + +export const SubmitClientLogResponse = { + encode( + message: SubmitClientLogResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SubmitClientLogResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSubmitClientLogResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SubmitClientLogResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: SubmitClientLogResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SubmitClientLogResponse { + const message = createBaseSubmitClientLogResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseLoadScratchInformationRequest(): LoadScratchInformationRequest { + return { userId: 0 }; +} + +export const LoadScratchInformationRequest = { + encode( + message: LoadScratchInformationRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadScratchInformationRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadScratchInformationRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadScratchInformationRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: LoadScratchInformationRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadScratchInformationRequest { + const message = createBaseLoadScratchInformationRequest(); + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseLoadScratchInformationResponse(): LoadScratchInformationResponse { + return { + error: 0, + scratchSheets: [], + currentSheet: 0, + numOfScratched: 0, + ownedUserItems: [], + }; +} + +export const LoadScratchInformationResponse = { + encode( + message: LoadScratchInformationResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.scratchSheets) { + ScratchSheet.encode(v!, writer.uint32(18).fork()).ldelim(); + } + if (message.currentSheet !== 0) { + writer.uint32(24).uint32(message.currentSheet); + } + if (message.numOfScratched !== 0) { + writer.uint32(32).uint32(message.numOfScratched); + } + for (const v of message.ownedUserItems) { + UserItem.encode(v!, writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadScratchInformationResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadScratchInformationResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.scratchSheets.push( + ScratchSheet.decode(reader, reader.uint32()) + ); + break; + case 3: + message.currentSheet = reader.uint32(); + break; + case 4: + message.numOfScratched = reader.uint32(); + break; + case 5: + message.ownedUserItems.push(UserItem.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadScratchInformationResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + scratchSheets: Array.isArray(object?.scratchSheets) + ? object.scratchSheets.map((e: any) => ScratchSheet.fromJSON(e)) + : [], + currentSheet: isSet(object.currentSheet) + ? Number(object.currentSheet) + : 0, + numOfScratched: isSet(object.numOfScratched) + ? Number(object.numOfScratched) + : 0, + ownedUserItems: Array.isArray(object?.ownedUserItems) + ? object.ownedUserItems.map((e: any) => UserItem.fromJSON(e)) + : [], + }; + }, + + toJSON(message: LoadScratchInformationResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.scratchSheets) { + obj.scratchSheets = message.scratchSheets.map((e) => + e ? ScratchSheet.toJSON(e) : undefined + ); + } else { + obj.scratchSheets = []; + } + message.currentSheet !== undefined && + (obj.currentSheet = Math.round(message.currentSheet)); + message.numOfScratched !== undefined && + (obj.numOfScratched = Math.round(message.numOfScratched)); + if (message.ownedUserItems) { + obj.ownedUserItems = message.ownedUserItems.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.ownedUserItems = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadScratchInformationResponse { + const message = createBaseLoadScratchInformationResponse(); + message.error = object.error ?? 0; + message.scratchSheets = + object.scratchSheets?.map((e) => ScratchSheet.fromPartial(e)) || []; + message.currentSheet = object.currentSheet ?? 0; + message.numOfScratched = object.numOfScratched ?? 0; + message.ownedUserItems = + object.ownedUserItems?.map((e) => UserItem.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseSaveScratchSheetRequest(): SaveScratchSheetRequest { + return { timestamp: 0, targetSheet: 0, targetSquare: 0, userId: 0 }; +} + +export const SaveScratchSheetRequest = { + encode( + message: SaveScratchSheetRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.timestamp !== 0) { + writer.uint32(56).uint32(message.timestamp); + } + if (message.targetSheet !== 0) { + writer.uint32(8).uint32(message.targetSheet); + } + if (message.targetSquare !== 0) { + writer.uint32(16).uint32(message.targetSquare); + } + if (message.userId !== 0) { + writer.uint32(24).uint32(message.userId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScratchSheetRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScratchSheetRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 7: + message.timestamp = reader.uint32(); + break; + case 1: + message.targetSheet = reader.uint32(); + break; + case 2: + message.targetSquare = reader.uint32(); + break; + case 3: + message.userId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScratchSheetRequest { + return { + timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0, + targetSheet: isSet(object.targetSheet) ? Number(object.targetSheet) : 0, + targetSquare: isSet(object.targetSquare) + ? Number(object.targetSquare) + : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + }; + }, + + toJSON(message: SaveScratchSheetRequest): unknown { + const obj: any = {}; + message.timestamp !== undefined && + (obj.timestamp = Math.round(message.timestamp)); + message.targetSheet !== undefined && + (obj.targetSheet = Math.round(message.targetSheet)); + message.targetSquare !== undefined && + (obj.targetSquare = Math.round(message.targetSquare)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveScratchSheetRequest { + const message = createBaseSaveScratchSheetRequest(); + message.timestamp = object.timestamp ?? 0; + message.targetSheet = object.targetSheet ?? 0; + message.targetSquare = object.targetSquare ?? 0; + message.userId = object.userId ?? 0; + return message; + }, +}; + +function createBaseSaveScratchSheetResponse(): SaveScratchSheetResponse { + return { + error: 0, + scratchSheets: [], + currentSheet: 0, + numOfScratched: 0, + earnedItem: undefined, + }; +} + +export const SaveScratchSheetResponse = { + encode( + message: SaveScratchSheetResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.scratchSheets) { + ScratchSheet.encode(v!, writer.uint32(18).fork()).ldelim(); + } + if (message.currentSheet !== 0) { + writer.uint32(24).uint32(message.currentSheet); + } + if (message.numOfScratched !== 0) { + writer.uint32(32).uint32(message.numOfScratched); + } + if (message.earnedItem !== undefined) { + UserItem.encode(message.earnedItem, writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SaveScratchSheetResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSaveScratchSheetResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.scratchSheets.push( + ScratchSheet.decode(reader, reader.uint32()) + ); + break; + case 3: + message.currentSheet = reader.uint32(); + break; + case 4: + message.numOfScratched = reader.uint32(); + break; + case 5: + message.earnedItem = UserItem.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SaveScratchSheetResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + scratchSheets: Array.isArray(object?.scratchSheets) + ? object.scratchSheets.map((e: any) => ScratchSheet.fromJSON(e)) + : [], + currentSheet: isSet(object.currentSheet) + ? Number(object.currentSheet) + : 0, + numOfScratched: isSet(object.numOfScratched) + ? Number(object.numOfScratched) + : 0, + earnedItem: isSet(object.earnedItem) + ? UserItem.fromJSON(object.earnedItem) + : undefined, + }; + }, + + toJSON(message: SaveScratchSheetResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.scratchSheets) { + obj.scratchSheets = message.scratchSheets.map((e) => + e ? ScratchSheet.toJSON(e) : undefined + ); + } else { + obj.scratchSheets = []; + } + message.currentSheet !== undefined && + (obj.currentSheet = Math.round(message.currentSheet)); + message.numOfScratched !== undefined && + (obj.numOfScratched = Math.round(message.numOfScratched)); + message.earnedItem !== undefined && + (obj.earnedItem = message.earnedItem + ? UserItem.toJSON(message.earnedItem) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): SaveScratchSheetResponse { + const message = createBaseSaveScratchSheetResponse(); + message.error = object.error ?? 0; + message.scratchSheets = + object.scratchSheets?.map((e) => ScratchSheet.fromPartial(e)) || []; + message.currentSheet = object.currentSheet ?? 0; + message.numOfScratched = object.numOfScratched ?? 0; + message.earnedItem = + object.earnedItem !== undefined && object.earnedItem !== null + ? UserItem.fromPartial(object.earnedItem) + : undefined; + return message; + }, +}; + +function createBaseTurnScratchSheetRequest(): TurnScratchSheetRequest { + return { userId: 0, targetSheet: 0 }; +} + +export const TurnScratchSheetRequest = { + encode( + message: TurnScratchSheetRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + if (message.targetSheet !== 0) { + writer.uint32(16).uint32(message.targetSheet); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): TurnScratchSheetRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTurnScratchSheetRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.targetSheet = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TurnScratchSheetRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + targetSheet: isSet(object.targetSheet) ? Number(object.targetSheet) : 0, + }; + }, + + toJSON(message: TurnScratchSheetRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.targetSheet !== undefined && + (obj.targetSheet = Math.round(message.targetSheet)); + return obj; + }, + + fromPartial, I>>( + object: I + ): TurnScratchSheetRequest { + const message = createBaseTurnScratchSheetRequest(); + message.userId = object.userId ?? 0; + message.targetSheet = object.targetSheet ?? 0; + return message; + }, +}; + +function createBaseTurnScratchSheetResponse(): TurnScratchSheetResponse { + return { error: 0 }; +} + +export const TurnScratchSheetResponse = { + encode( + message: TurnScratchSheetResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): TurnScratchSheetResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTurnScratchSheetResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TurnScratchSheetResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: TurnScratchSheetResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): TurnScratchSheetResponse { + const message = createBaseTurnScratchSheetResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseCheckItemReceivableCarsRequest(): CheckItemReceivableCarsRequest { + return { userId: 0, itemsToBeEarned: [] }; +} + +export const CheckItemReceivableCarsRequest = { + encode( + message: CheckItemReceivableCarsRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + for (const v of message.itemsToBeEarned) { + UserItem.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): CheckItemReceivableCarsRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCheckItemReceivableCarsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.itemsToBeEarned.push( + UserItem.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CheckItemReceivableCarsRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + itemsToBeEarned: Array.isArray(object?.itemsToBeEarned) + ? object.itemsToBeEarned.map((e: any) => UserItem.fromJSON(e)) + : [], + }; + }, + + toJSON(message: CheckItemReceivableCarsRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + if (message.itemsToBeEarned) { + obj.itemsToBeEarned = message.itemsToBeEarned.map((e) => + e ? UserItem.toJSON(e) : undefined + ); + } else { + obj.itemsToBeEarned = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): CheckItemReceivableCarsRequest { + const message = createBaseCheckItemReceivableCarsRequest(); + message.userId = object.userId ?? 0; + message.itemsToBeEarned = + object.itemsToBeEarned?.map((e) => UserItem.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseCheckItemReceivableCarsResponse(): CheckItemReceivableCarsResponse { + return { error: 0, carIds: [] }; +} + +export const CheckItemReceivableCarsResponse = { + encode( + message: CheckItemReceivableCarsResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + writer.uint32(18).fork(); + for (const v of message.carIds) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): CheckItemReceivableCarsResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCheckItemReceivableCarsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.carIds.push(reader.uint32()); + } + } else { + message.carIds.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CheckItemReceivableCarsResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + carIds: Array.isArray(object?.carIds) + ? object.carIds.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: CheckItemReceivableCarsResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.carIds) { + obj.carIds = message.carIds.map((e) => Math.round(e)); + } else { + obj.carIds = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): CheckItemReceivableCarsResponse { + const message = createBaseCheckItemReceivableCarsResponse(); + message.error = object.error ?? 0; + message.carIds = object.carIds?.map((e) => e) || []; + return message; + }, +}; + +function createBaseReceiveUserItemsRequest(): ReceiveUserItemsRequest { + return { carId: 0, targetItemIds: [] }; +} + +export const ReceiveUserItemsRequest = { + encode( + message: ReceiveUserItemsRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + writer.uint32(18).fork(); + for (const v of message.targetItemIds) { + writer.uint32(v); + } + writer.ldelim(); + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ReceiveUserItemsRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseReceiveUserItemsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.targetItemIds.push(reader.uint32()); + } + } else { + message.targetItemIds.push(reader.uint32()); + } + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ReceiveUserItemsRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + targetItemIds: Array.isArray(object?.targetItemIds) + ? object.targetItemIds.map((e: any) => Number(e)) + : [], + }; + }, + + toJSON(message: ReceiveUserItemsRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + if (message.targetItemIds) { + obj.targetItemIds = message.targetItemIds.map((e) => Math.round(e)); + } else { + obj.targetItemIds = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): ReceiveUserItemsRequest { + const message = createBaseReceiveUserItemsRequest(); + message.carId = object.carId ?? 0; + message.targetItemIds = object.targetItemIds?.map((e) => e) || []; + return message; + }, +}; + +function createBaseReceiveUserItemsResponse(): ReceiveUserItemsResponse { + return { error: 0 }; +} + +export const ReceiveUserItemsResponse = { + encode( + message: ReceiveUserItemsResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ReceiveUserItemsResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseReceiveUserItemsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ReceiveUserItemsResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: ReceiveUserItemsResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): ReceiveUserItemsResponse { + const message = createBaseReceiveUserItemsResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseUpdateEventModeSerialRequest(): UpdateEventModeSerialRequest { + return { eventModeSerial: "" }; +} + +export const UpdateEventModeSerialRequest = { + encode( + message: UpdateEventModeSerialRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.eventModeSerial !== "") { + writer.uint32(10).string(message.eventModeSerial); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): UpdateEventModeSerialRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateEventModeSerialRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.eventModeSerial = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpdateEventModeSerialRequest { + return { + eventModeSerial: isSet(object.eventModeSerial) + ? String(object.eventModeSerial) + : "", + }; + }, + + toJSON(message: UpdateEventModeSerialRequest): unknown { + const obj: any = {}; + message.eventModeSerial !== undefined && + (obj.eventModeSerial = message.eventModeSerial); + return obj; + }, + + fromPartial, I>>( + object: I + ): UpdateEventModeSerialRequest { + const message = createBaseUpdateEventModeSerialRequest(); + message.eventModeSerial = object.eventModeSerial ?? ""; + return message; + }, +}; + +function createBaseUpdateEventModeSerialResponse(): UpdateEventModeSerialResponse { + return { + error: 0, + serialError: 0, + eventModeSerial: "", + startAt: 0, + endAt: 0, + }; +} + +export const UpdateEventModeSerialResponse = { + encode( + message: UpdateEventModeSerialResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.serialError !== 0) { + writer.uint32(32).int32(message.serialError); + } + if (message.eventModeSerial !== "") { + writer.uint32(18).string(message.eventModeSerial); + } + if (message.startAt !== 0) { + writer.uint32(40).uint32(message.startAt); + } + if (message.endAt !== 0) { + writer.uint32(24).uint32(message.endAt); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): UpdateEventModeSerialResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateEventModeSerialResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 4: + message.serialError = reader.int32() as any; + break; + case 2: + message.eventModeSerial = reader.string(); + break; + case 5: + message.startAt = reader.uint32(); + break; + case 3: + message.endAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpdateEventModeSerialResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + serialError: isSet(object.serialError) + ? eventModeSerialErrorCodeFromJSON(object.serialError) + : 0, + eventModeSerial: isSet(object.eventModeSerial) + ? String(object.eventModeSerial) + : "", + startAt: isSet(object.startAt) ? Number(object.startAt) : 0, + endAt: isSet(object.endAt) ? Number(object.endAt) : 0, + }; + }, + + toJSON(message: UpdateEventModeSerialResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.serialError !== undefined && + (obj.serialError = eventModeSerialErrorCodeToJSON(message.serialError)); + message.eventModeSerial !== undefined && + (obj.eventModeSerial = message.eventModeSerial); + message.startAt !== undefined && + (obj.startAt = Math.round(message.startAt)); + message.endAt !== undefined && (obj.endAt = Math.round(message.endAt)); + return obj; + }, + + fromPartial, I>>( + object: I + ): UpdateEventModeSerialResponse { + const message = createBaseUpdateEventModeSerialResponse(); + message.error = object.error ?? 0; + message.serialError = object.serialError ?? 0; + message.eventModeSerial = object.eventModeSerial ?? ""; + message.startAt = object.startAt ?? 0; + message.endAt = object.endAt ?? 0; + return message; + }, +}; + +function createBaseParticipateInInviteFriendCampaignRequest(): ParticipateInInviteFriendCampaignRequest { + return { + invitingUserId: 0, + invitedUserId: 0, + sourceCarId: 0, + transmission: false, + }; +} + +export const ParticipateInInviteFriendCampaignRequest = { + encode( + message: ParticipateInInviteFriendCampaignRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.invitingUserId !== 0) { + writer.uint32(8).uint32(message.invitingUserId); + } + if (message.invitedUserId !== 0) { + writer.uint32(16).uint32(message.invitedUserId); + } + if (message.sourceCarId !== 0) { + writer.uint32(24).uint32(message.sourceCarId); + } + if (message.transmission === true) { + writer.uint32(32).bool(message.transmission); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ParticipateInInviteFriendCampaignRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseParticipateInInviteFriendCampaignRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.invitingUserId = reader.uint32(); + break; + case 2: + message.invitedUserId = reader.uint32(); + break; + case 3: + message.sourceCarId = reader.uint32(); + break; + case 4: + message.transmission = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ParticipateInInviteFriendCampaignRequest { + return { + invitingUserId: isSet(object.invitingUserId) + ? Number(object.invitingUserId) + : 0, + invitedUserId: isSet(object.invitedUserId) + ? Number(object.invitedUserId) + : 0, + sourceCarId: isSet(object.sourceCarId) ? Number(object.sourceCarId) : 0, + transmission: isSet(object.transmission) + ? Boolean(object.transmission) + : false, + }; + }, + + toJSON(message: ParticipateInInviteFriendCampaignRequest): unknown { + const obj: any = {}; + message.invitingUserId !== undefined && + (obj.invitingUserId = Math.round(message.invitingUserId)); + message.invitedUserId !== undefined && + (obj.invitedUserId = Math.round(message.invitedUserId)); + message.sourceCarId !== undefined && + (obj.sourceCarId = Math.round(message.sourceCarId)); + message.transmission !== undefined && + (obj.transmission = message.transmission); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): ParticipateInInviteFriendCampaignRequest { + const message = createBaseParticipateInInviteFriendCampaignRequest(); + message.invitingUserId = object.invitingUserId ?? 0; + message.invitedUserId = object.invitedUserId ?? 0; + message.sourceCarId = object.sourceCarId ?? 0; + message.transmission = object.transmission ?? false; + return message; + }, +}; + +function createBaseParticipateInInviteFriendCampaignResponse(): ParticipateInInviteFriendCampaignResponse { + return { error: 0 }; +} + +export const ParticipateInInviteFriendCampaignResponse = { + encode( + message: ParticipateInInviteFriendCampaignResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ParticipateInInviteFriendCampaignResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseParticipateInInviteFriendCampaignResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ParticipateInInviteFriendCampaignResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: ParticipateInInviteFriendCampaignResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): ParticipateInInviteFriendCampaignResponse { + const message = createBaseParticipateInInviteFriendCampaignResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseConsumeUserItemRequest(): ConsumeUserItemRequest { + return { userId: 0, carId: 0, userItemId: 0 }; +} + +export const ConsumeUserItemRequest = { + encode( + message: ConsumeUserItemRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.userId !== 0) { + writer.uint32(8).uint32(message.userId); + } + if (message.carId !== 0) { + writer.uint32(16).uint32(message.carId); + } + if (message.userItemId !== 0) { + writer.uint32(24).uint32(message.userItemId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ConsumeUserItemRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseConsumeUserItemRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.userId = reader.uint32(); + break; + case 2: + message.carId = reader.uint32(); + break; + case 3: + message.userItemId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ConsumeUserItemRequest { + return { + userId: isSet(object.userId) ? Number(object.userId) : 0, + carId: isSet(object.carId) ? Number(object.carId) : 0, + userItemId: isSet(object.userItemId) ? Number(object.userItemId) : 0, + }; + }, + + toJSON(message: ConsumeUserItemRequest): unknown { + const obj: any = {}; + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.userItemId !== undefined && + (obj.userItemId = Math.round(message.userItemId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): ConsumeUserItemRequest { + const message = createBaseConsumeUserItemRequest(); + message.userId = object.userId ?? 0; + message.carId = object.carId ?? 0; + message.userItemId = object.userItemId ?? 0; + return message; + }, +}; + +function createBaseConsumeUserItemResponse(): ConsumeUserItemResponse { + return { error: 0 }; +} + +export const ConsumeUserItemResponse = { + encode( + message: ConsumeUserItemResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ConsumeUserItemResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseConsumeUserItemResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ConsumeUserItemResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + }; + }, + + toJSON(message: ConsumeUserItemResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + return obj; + }, + + fromPartial, I>>( + object: I + ): ConsumeUserItemResponse { + const message = createBaseConsumeUserItemResponse(); + message.error = object.error ?? 0; + return message; + }, +}; + +function createBaseSearchCarsByLevelRequest(): SearchCarsByLevelRequest { + return { carId: 0, ghostLevel: 0, area: 0, regionId: 0 }; +} + +export const SearchCarsByLevelRequest = { + encode( + message: SearchCarsByLevelRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.ghostLevel !== 0) { + writer.uint32(16).uint32(message.ghostLevel); + } + if (message.area !== 0) { + writer.uint32(24).uint32(message.area); + } + if (message.regionId !== 0) { + writer.uint32(32).uint32(message.regionId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SearchCarsByLevelRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSearchCarsByLevelRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.ghostLevel = reader.uint32(); + break; + case 3: + message.area = reader.uint32(); + break; + case 4: + message.regionId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SearchCarsByLevelRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + ghostLevel: isSet(object.ghostLevel) ? Number(object.ghostLevel) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + }; + }, + + toJSON(message: SearchCarsByLevelRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.ghostLevel !== undefined && + (obj.ghostLevel = Math.round(message.ghostLevel)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SearchCarsByLevelRequest { + const message = createBaseSearchCarsByLevelRequest(); + message.carId = object.carId ?? 0; + message.ghostLevel = object.ghostLevel ?? 0; + message.area = object.area ?? 0; + message.regionId = object.regionId ?? 0; + return message; + }, +}; + +function createBaseSearchCarsByLevelResponse(): SearchCarsByLevelResponse { + return { + error: 0, + ramp: 0, + path: 0, + ghosts: [], + selectionMethod: 1, + rates: [], + }; +} + +export const SearchCarsByLevelResponse = { + encode( + message: SearchCarsByLevelResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + if (message.ramp !== 0) { + writer.uint32(16).uint32(message.ramp); + } + if (message.path !== 0) { + writer.uint32(24).uint32(message.path); + } + for (const v of message.ghosts) { + GhostCar.encode(v!, writer.uint32(34).fork()).ldelim(); + } + if (message.selectionMethod !== 1) { + writer.uint32(40).int32(message.selectionMethod); + } + for (const v of message.rates) { + SearchCarsByLevelResponse_Rate.encode( + v!, + writer.uint32(50).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SearchCarsByLevelResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSearchCarsByLevelResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.ramp = reader.uint32(); + break; + case 3: + message.path = reader.uint32(); + break; + case 4: + message.ghosts.push(GhostCar.decode(reader, reader.uint32())); + break; + case 5: + message.selectionMethod = reader.int32() as any; + break; + case 6: + message.rates.push( + SearchCarsByLevelResponse_Rate.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SearchCarsByLevelResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + ramp: isSet(object.ramp) ? Number(object.ramp) : 0, + path: isSet(object.path) ? Number(object.path) : 0, + ghosts: Array.isArray(object?.ghosts) + ? object.ghosts.map((e: any) => GhostCar.fromJSON(e)) + : [], + selectionMethod: isSet(object.selectionMethod) + ? pathSelectionMethodFromJSON(object.selectionMethod) + : 1, + rates: Array.isArray(object?.rates) + ? object.rates.map((e: any) => + SearchCarsByLevelResponse_Rate.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: SearchCarsByLevelResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + message.ramp !== undefined && (obj.ramp = Math.round(message.ramp)); + message.path !== undefined && (obj.path = Math.round(message.path)); + if (message.ghosts) { + obj.ghosts = message.ghosts.map((e) => + e ? GhostCar.toJSON(e) : undefined + ); + } else { + obj.ghosts = []; + } + message.selectionMethod !== undefined && + (obj.selectionMethod = pathSelectionMethodToJSON( + message.selectionMethod + )); + if (message.rates) { + obj.rates = message.rates.map((e) => + e ? SearchCarsByLevelResponse_Rate.toJSON(e) : undefined + ); + } else { + obj.rates = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): SearchCarsByLevelResponse { + const message = createBaseSearchCarsByLevelResponse(); + message.error = object.error ?? 0; + message.ramp = object.ramp ?? 0; + message.path = object.path ?? 0; + message.ghosts = object.ghosts?.map((e) => GhostCar.fromPartial(e)) || []; + message.selectionMethod = object.selectionMethod ?? 1; + message.rates = + object.rates?.map((e) => SearchCarsByLevelResponse_Rate.fromPartial(e)) || + []; + return message; + }, +}; + +function createBaseSearchCarsByLevelResponse_Rate(): SearchCarsByLevelResponse_Rate { + return { carId: 0, type: 1, rate: 0 }; +} + +export const SearchCarsByLevelResponse_Rate = { + encode( + message: SearchCarsByLevelResponse_Rate, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.type !== 1) { + writer.uint32(16).int32(message.type); + } + if (message.rate !== 0) { + writer.uint32(24).uint32(message.rate); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): SearchCarsByLevelResponse_Rate { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSearchCarsByLevelResponse_Rate(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.type = reader.int32() as any; + break; + case 3: + message.rate = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SearchCarsByLevelResponse_Rate { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + type: isSet(object.type) ? ghostRateTypeFromJSON(object.type) : 1, + rate: isSet(object.rate) ? Number(object.rate) : 0, + }; + }, + + toJSON(message: SearchCarsByLevelResponse_Rate): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.type !== undefined && + (obj.type = ghostRateTypeToJSON(message.type)); + message.rate !== undefined && (obj.rate = Math.round(message.rate)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SearchCarsByLevelResponse_Rate { + const message = createBaseSearchCarsByLevelResponse_Rate(); + message.carId = object.carId ?? 0; + message.type = object.type ?? 1; + message.rate = object.rate ?? 0; + return message; + }, +}; + +function createBaseLoadPathsAndTuningsRequest(): LoadPathsAndTuningsRequest { + return { + carId: 0, + selectedCars: [], + returnImmediately: false, + stampTargetArea: 0, + }; +} + +export const LoadPathsAndTuningsRequest = { + encode( + message: LoadPathsAndTuningsRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + writer.uint32(18).fork(); + for (const v of message.selectedCars) { + writer.uint32(v); + } + writer.ldelim(); + if (message.returnImmediately === true) { + writer.uint32(24).bool(message.returnImmediately); + } + if (message.stampTargetArea !== 0) { + writer.uint32(32).uint32(message.stampTargetArea); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadPathsAndTuningsRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadPathsAndTuningsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.selectedCars.push(reader.uint32()); + } + } else { + message.selectedCars.push(reader.uint32()); + } + break; + case 3: + message.returnImmediately = reader.bool(); + break; + case 4: + message.stampTargetArea = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadPathsAndTuningsRequest { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + selectedCars: Array.isArray(object?.selectedCars) + ? object.selectedCars.map((e: any) => Number(e)) + : [], + returnImmediately: isSet(object.returnImmediately) + ? Boolean(object.returnImmediately) + : false, + stampTargetArea: isSet(object.stampTargetArea) + ? Number(object.stampTargetArea) + : 0, + }; + }, + + toJSON(message: LoadPathsAndTuningsRequest): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + if (message.selectedCars) { + obj.selectedCars = message.selectedCars.map((e) => Math.round(e)); + } else { + obj.selectedCars = []; + } + message.returnImmediately !== undefined && + (obj.returnImmediately = message.returnImmediately); + message.stampTargetArea !== undefined && + (obj.stampTargetArea = Math.round(message.stampTargetArea)); + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadPathsAndTuningsRequest { + const message = createBaseLoadPathsAndTuningsRequest(); + message.carId = object.carId ?? 0; + message.selectedCars = object.selectedCars?.map((e) => e) || []; + message.returnImmediately = object.returnImmediately ?? false; + message.stampTargetArea = object.stampTargetArea ?? 0; + return message; + }, +}; + +function createBaseLoadPathsAndTuningsResponse(): LoadPathsAndTuningsResponse { + return { error: 0, data: [] }; +} + +export const LoadPathsAndTuningsResponse = { + encode( + message: LoadPathsAndTuningsResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.data) { + LoadPathsAndTuningsResponse_CarTuningsByPath.encode( + v!, + writer.uint32(18).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadPathsAndTuningsResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadPathsAndTuningsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.data.push( + LoadPathsAndTuningsResponse_CarTuningsByPath.decode( + reader, + reader.uint32() + ) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadPathsAndTuningsResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + data: Array.isArray(object?.data) + ? object.data.map((e: any) => + LoadPathsAndTuningsResponse_CarTuningsByPath.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: LoadPathsAndTuningsResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.data) { + obj.data = message.data.map((e) => + e ? LoadPathsAndTuningsResponse_CarTuningsByPath.toJSON(e) : undefined + ); + } else { + obj.data = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadPathsAndTuningsResponse { + const message = createBaseLoadPathsAndTuningsResponse(); + message.error = object.error ?? 0; + message.data = + object.data?.map((e) => + LoadPathsAndTuningsResponse_CarTuningsByPath.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseLoadPathsAndTuningsResponse_CarTuningsByPath(): LoadPathsAndTuningsResponse_CarTuningsByPath { + return { area: 0, ramp: 0, path: 0, carTunings: [], selectionMethod: 1 }; +} + +export const LoadPathsAndTuningsResponse_CarTuningsByPath = { + encode( + message: LoadPathsAndTuningsResponse_CarTuningsByPath, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.area !== 0) { + writer.uint32(8).uint32(message.area); + } + if (message.ramp !== 0) { + writer.uint32(16).uint32(message.ramp); + } + if (message.path !== 0) { + writer.uint32(24).uint32(message.path); + } + for (const v of message.carTunings) { + CarTuning.encode(v!, writer.uint32(34).fork()).ldelim(); + } + if (message.selectionMethod !== 1) { + writer.uint32(40).int32(message.selectionMethod); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadPathsAndTuningsResponse_CarTuningsByPath { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadPathsAndTuningsResponse_CarTuningsByPath(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.area = reader.uint32(); + break; + case 2: + message.ramp = reader.uint32(); + break; + case 3: + message.path = reader.uint32(); + break; + case 4: + message.carTunings.push(CarTuning.decode(reader, reader.uint32())); + break; + case 5: + message.selectionMethod = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadPathsAndTuningsResponse_CarTuningsByPath { + return { + area: isSet(object.area) ? Number(object.area) : 0, + ramp: isSet(object.ramp) ? Number(object.ramp) : 0, + path: isSet(object.path) ? Number(object.path) : 0, + carTunings: Array.isArray(object?.carTunings) + ? object.carTunings.map((e: any) => CarTuning.fromJSON(e)) + : [], + selectionMethod: isSet(object.selectionMethod) + ? pathSelectionMethodFromJSON(object.selectionMethod) + : 1, + }; + }, + + toJSON(message: LoadPathsAndTuningsResponse_CarTuningsByPath): unknown { + const obj: any = {}; + message.area !== undefined && (obj.area = Math.round(message.area)); + message.ramp !== undefined && (obj.ramp = Math.round(message.ramp)); + message.path !== undefined && (obj.path = Math.round(message.path)); + if (message.carTunings) { + obj.carTunings = message.carTunings.map((e) => + e ? CarTuning.toJSON(e) : undefined + ); + } else { + obj.carTunings = []; + } + message.selectionMethod !== undefined && + (obj.selectionMethod = pathSelectionMethodToJSON( + message.selectionMethod + )); + return obj; + }, + + fromPartial< + I extends Exact< + DeepPartial, + I + > + >(object: I): LoadPathsAndTuningsResponse_CarTuningsByPath { + const message = createBaseLoadPathsAndTuningsResponse_CarTuningsByPath(); + message.area = object.area ?? 0; + message.ramp = object.ramp ?? 0; + message.path = object.path ?? 0; + message.carTunings = + object.carTunings?.map((e) => CarTuning.fromPartial(e)) || []; + message.selectionMethod = object.selectionMethod ?? 1; + return message; + }, +}; + +function createBaseLoadGhostDriveDataRequest(): LoadGhostDriveDataRequest { + return { path: 0, carTunings: [] }; +} + +export const LoadGhostDriveDataRequest = { + encode( + message: LoadGhostDriveDataRequest, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.path !== 0) { + writer.uint32(8).uint32(message.path); + } + for (const v of message.carTunings) { + CarTuning.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostDriveDataRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostDriveDataRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.path = reader.uint32(); + break; + case 2: + message.carTunings.push(CarTuning.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostDriveDataRequest { + return { + path: isSet(object.path) ? Number(object.path) : 0, + carTunings: Array.isArray(object?.carTunings) + ? object.carTunings.map((e: any) => CarTuning.fromJSON(e)) + : [], + }; + }, + + toJSON(message: LoadGhostDriveDataRequest): unknown { + const obj: any = {}; + message.path !== undefined && (obj.path = Math.round(message.path)); + if (message.carTunings) { + obj.carTunings = message.carTunings.map((e) => + e ? CarTuning.toJSON(e) : undefined + ); + } else { + obj.carTunings = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGhostDriveDataRequest { + const message = createBaseLoadGhostDriveDataRequest(); + message.path = object.path ?? 0; + message.carTunings = + object.carTunings?.map((e) => CarTuning.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseLoadGhostDriveDataResponse(): LoadGhostDriveDataResponse { + return { error: 0, data: [] }; +} + +export const LoadGhostDriveDataResponse = { + encode( + message: LoadGhostDriveDataResponse, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.error !== 0) { + writer.uint32(8).int32(message.error); + } + for (const v of message.data) { + LoadGhostDriveDataResponse_GhostDriveData.encode( + v!, + writer.uint32(18).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostDriveDataResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostDriveDataResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.error = reader.int32() as any; + break; + case 2: + message.data.push( + LoadGhostDriveDataResponse_GhostDriveData.decode( + reader, + reader.uint32() + ) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostDriveDataResponse { + return { + error: isSet(object.error) ? errorCodeFromJSON(object.error) : 0, + data: Array.isArray(object?.data) + ? object.data.map((e: any) => + LoadGhostDriveDataResponse_GhostDriveData.fromJSON(e) + ) + : [], + }; + }, + + toJSON(message: LoadGhostDriveDataResponse): unknown { + const obj: any = {}; + message.error !== undefined && (obj.error = errorCodeToJSON(message.error)); + if (message.data) { + obj.data = message.data.map((e) => + e ? LoadGhostDriveDataResponse_GhostDriveData.toJSON(e) : undefined + ); + } else { + obj.data = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): LoadGhostDriveDataResponse { + const message = createBaseLoadGhostDriveDataResponse(); + message.error = object.error ?? 0; + message.data = + object.data?.map((e) => + LoadGhostDriveDataResponse_GhostDriveData.fromPartial(e) + ) || []; + return message; + }, +}; + +function createBaseLoadGhostDriveDataResponse_GhostDriveData(): LoadGhostDriveDataResponse_GhostDriveData { + return { + carId: 0, + type: 1, + driveData: undefined, + trendBinaryByUser: undefined, + trendBinaryByCar: undefined, + trendBinaryByArea: undefined, + }; +} + +export const LoadGhostDriveDataResponse_GhostDriveData = { + encode( + message: LoadGhostDriveDataResponse_GhostDriveData, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.type !== 1) { + writer.uint32(16).int32(message.type); + } + if (message.driveData !== undefined) { + BinaryData.encode(message.driveData, writer.uint32(26).fork()).ldelim(); + } + if (message.trendBinaryByUser !== undefined) { + BinaryData.encode( + message.trendBinaryByUser, + writer.uint32(34).fork() + ).ldelim(); + } + if (message.trendBinaryByCar !== undefined) { + BinaryData.encode( + message.trendBinaryByCar, + writer.uint32(42).fork() + ).ldelim(); + } + if (message.trendBinaryByArea !== undefined) { + BinaryData.encode( + message.trendBinaryByArea, + writer.uint32(50).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): LoadGhostDriveDataResponse_GhostDriveData { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoadGhostDriveDataResponse_GhostDriveData(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.type = reader.int32() as any; + break; + case 3: + message.driveData = BinaryData.decode(reader, reader.uint32()); + break; + case 4: + message.trendBinaryByUser = BinaryData.decode( + reader, + reader.uint32() + ); + break; + case 5: + message.trendBinaryByCar = BinaryData.decode(reader, reader.uint32()); + break; + case 6: + message.trendBinaryByArea = BinaryData.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): LoadGhostDriveDataResponse_GhostDriveData { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + type: isSet(object.type) ? ghostTypeFromJSON(object.type) : 1, + driveData: isSet(object.driveData) + ? BinaryData.fromJSON(object.driveData) + : undefined, + trendBinaryByUser: isSet(object.trendBinaryByUser) + ? BinaryData.fromJSON(object.trendBinaryByUser) + : undefined, + trendBinaryByCar: isSet(object.trendBinaryByCar) + ? BinaryData.fromJSON(object.trendBinaryByCar) + : undefined, + trendBinaryByArea: isSet(object.trendBinaryByArea) + ? BinaryData.fromJSON(object.trendBinaryByArea) + : undefined, + }; + }, + + toJSON(message: LoadGhostDriveDataResponse_GhostDriveData): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.type !== undefined && (obj.type = ghostTypeToJSON(message.type)); + message.driveData !== undefined && + (obj.driveData = message.driveData + ? BinaryData.toJSON(message.driveData) + : undefined); + message.trendBinaryByUser !== undefined && + (obj.trendBinaryByUser = message.trendBinaryByUser + ? BinaryData.toJSON(message.trendBinaryByUser) + : undefined); + message.trendBinaryByCar !== undefined && + (obj.trendBinaryByCar = message.trendBinaryByCar + ? BinaryData.toJSON(message.trendBinaryByCar) + : undefined); + message.trendBinaryByArea !== undefined && + (obj.trendBinaryByArea = message.trendBinaryByArea + ? BinaryData.toJSON(message.trendBinaryByArea) + : undefined); + return obj; + }, + + fromPartial< + I extends Exact, I> + >(object: I): LoadGhostDriveDataResponse_GhostDriveData { + const message = createBaseLoadGhostDriveDataResponse_GhostDriveData(); + message.carId = object.carId ?? 0; + message.type = object.type ?? 1; + message.driveData = + object.driveData !== undefined && object.driveData !== null + ? BinaryData.fromPartial(object.driveData) + : undefined; + message.trendBinaryByUser = + object.trendBinaryByUser !== undefined && + object.trendBinaryByUser !== null + ? BinaryData.fromPartial(object.trendBinaryByUser) + : undefined; + message.trendBinaryByCar = + object.trendBinaryByCar !== undefined && object.trendBinaryByCar !== null + ? BinaryData.fromPartial(object.trendBinaryByCar) + : undefined; + message.trendBinaryByArea = + object.trendBinaryByArea !== undefined && + object.trendBinaryByArea !== null + ? BinaryData.fromPartial(object.trendBinaryByArea) + : undefined; + return message; + }, +}; + +function createBaseCar(): Car { + return { + carId: 0, + userId: 0, + regionId: 0, + name: "", + manufacturer: 0, + model: 0, + visualModel: 0, + defaultColor: 0, + customColor: 0, + wheel: 0, + wheelColor: 0, + aero: 0, + bonnet: 0, + wing: 0, + gtWing: undefined, + mirror: 0, + neon: 0, + trunk: 0, + plate: 0, + plateColor: 0, + plateNumber: 0, + tunePower: 0, + tuneHandling: 0, + title: "", + level: 0, + windowSticker: false, + windowStickerString: "", + windowStickerFont: 0, + windowDecoration: 0, + rivalMarker: 0, + lastPlayedAt: 0, + lastPlayedPlace: undefined, + aura: 0, + auraMotif: 0, + ghostLevel: 0, + country: "", + searchCode: "", + }; +} + +export const Car = { + encode(message: Car, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.userId !== 0) { + writer.uint32(16).uint32(message.userId); + } + if (message.regionId !== 0) { + writer.uint32(24).uint32(message.regionId); + } + if (message.name !== "") { + writer.uint32(34).string(message.name); + } + if (message.manufacturer !== 0) { + writer.uint32(40).uint32(message.manufacturer); + } + if (message.model !== 0) { + writer.uint32(48).uint32(message.model); + } + if (message.visualModel !== 0) { + writer.uint32(56).uint32(message.visualModel); + } + if (message.defaultColor !== 0) { + writer.uint32(64).uint32(message.defaultColor); + } + if (message.customColor !== 0) { + writer.uint32(72).uint32(message.customColor); + } + if (message.wheel !== 0) { + writer.uint32(80).uint32(message.wheel); + } + if (message.wheelColor !== 0) { + writer.uint32(88).uint32(message.wheelColor); + } + if (message.aero !== 0) { + writer.uint32(96).uint32(message.aero); + } + if (message.bonnet !== 0) { + writer.uint32(104).uint32(message.bonnet); + } + if (message.wing !== 0) { + writer.uint32(112).uint32(message.wing); + } + if (message.gtWing !== undefined) { + GTWing.encode(message.gtWing, writer.uint32(122).fork()).ldelim(); + } + if (message.mirror !== 0) { + writer.uint32(128).uint32(message.mirror); + } + if (message.neon !== 0) { + writer.uint32(192).uint32(message.neon); + } + if (message.trunk !== 0) { + writer.uint32(200).uint32(message.trunk); + } + if (message.plate !== 0) { + writer.uint32(208).uint32(message.plate); + } + if (message.plateColor !== 0) { + writer.uint32(216).uint32(message.plateColor); + } + if (message.plateNumber !== 0) { + writer.uint32(224).uint32(message.plateNumber); + } + if (message.tunePower !== 0) { + writer.uint32(248).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(256).uint32(message.tuneHandling); + } + if (message.title !== "") { + writer.uint32(266).string(message.title); + } + if (message.level !== 0) { + writer.uint32(272).uint32(message.level); + } + if (message.windowSticker === true) { + writer.uint32(280).bool(message.windowSticker); + } + if (message.windowStickerString !== "") { + writer.uint32(298).string(message.windowStickerString); + } + if (message.windowStickerFont !== 0) { + writer.uint32(304).uint32(message.windowStickerFont); + } + if (message.windowDecoration !== 0) { + writer.uint32(312).uint32(message.windowDecoration); + } + if (message.rivalMarker !== 0) { + writer.uint32(328).uint32(message.rivalMarker); + } + if (message.lastPlayedAt !== 0) { + writer.uint32(360).uint32(message.lastPlayedAt); + } + if (message.lastPlayedPlace !== undefined) { + Place.encode(message.lastPlayedPlace, writer.uint32(370).fork()).ldelim(); + } + if (message.aura !== 0) { + writer.uint32(376).uint32(message.aura); + } + if (message.auraMotif !== 0) { + writer.uint32(384).uint32(message.auraMotif); + } + if (message.ghostLevel !== 0) { + writer.uint32(392).uint32(message.ghostLevel); + } + if (message.country !== "") { + writer.uint32(402).string(message.country); + } + if (message.searchCode !== "") { + writer.uint32(410).string(message.searchCode); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Car { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.userId = reader.uint32(); + break; + case 3: + message.regionId = reader.uint32(); + break; + case 4: + message.name = reader.string(); + break; + case 5: + message.manufacturer = reader.uint32(); + break; + case 6: + message.model = reader.uint32(); + break; + case 7: + message.visualModel = reader.uint32(); + break; + case 8: + message.defaultColor = reader.uint32(); + break; + case 9: + message.customColor = reader.uint32(); + break; + case 10: + message.wheel = reader.uint32(); + break; + case 11: + message.wheelColor = reader.uint32(); + break; + case 12: + message.aero = reader.uint32(); + break; + case 13: + message.bonnet = reader.uint32(); + break; + case 14: + message.wing = reader.uint32(); + break; + case 15: + message.gtWing = GTWing.decode(reader, reader.uint32()); + break; + case 16: + message.mirror = reader.uint32(); + break; + case 24: + message.neon = reader.uint32(); + break; + case 25: + message.trunk = reader.uint32(); + break; + case 26: + message.plate = reader.uint32(); + break; + case 27: + message.plateColor = reader.uint32(); + break; + case 28: + message.plateNumber = reader.uint32(); + break; + case 31: + message.tunePower = reader.uint32(); + break; + case 32: + message.tuneHandling = reader.uint32(); + break; + case 33: + message.title = reader.string(); + break; + case 34: + message.level = reader.uint32(); + break; + case 35: + message.windowSticker = reader.bool(); + break; + case 37: + message.windowStickerString = reader.string(); + break; + case 38: + message.windowStickerFont = reader.uint32(); + break; + case 39: + message.windowDecoration = reader.uint32(); + break; + case 41: + message.rivalMarker = reader.uint32(); + break; + case 45: + message.lastPlayedAt = reader.uint32(); + break; + case 46: + message.lastPlayedPlace = Place.decode(reader, reader.uint32()); + break; + case 47: + message.aura = reader.uint32(); + break; + case 48: + message.auraMotif = reader.uint32(); + break; + case 49: + message.ghostLevel = reader.uint32(); + break; + case 50: + message.country = reader.string(); + break; + case 51: + message.searchCode = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Car { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + userId: isSet(object.userId) ? Number(object.userId) : 0, + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + name: isSet(object.name) ? String(object.name) : "", + manufacturer: isSet(object.manufacturer) + ? Number(object.manufacturer) + : 0, + model: isSet(object.model) ? Number(object.model) : 0, + visualModel: isSet(object.visualModel) ? Number(object.visualModel) : 0, + defaultColor: isSet(object.defaultColor) + ? Number(object.defaultColor) + : 0, + customColor: isSet(object.customColor) ? Number(object.customColor) : 0, + wheel: isSet(object.wheel) ? Number(object.wheel) : 0, + wheelColor: isSet(object.wheelColor) ? Number(object.wheelColor) : 0, + aero: isSet(object.aero) ? Number(object.aero) : 0, + bonnet: isSet(object.bonnet) ? Number(object.bonnet) : 0, + wing: isSet(object.wing) ? Number(object.wing) : 0, + gtWing: isSet(object.gtWing) ? GTWing.fromJSON(object.gtWing) : undefined, + mirror: isSet(object.mirror) ? Number(object.mirror) : 0, + neon: isSet(object.neon) ? Number(object.neon) : 0, + trunk: isSet(object.trunk) ? Number(object.trunk) : 0, + plate: isSet(object.plate) ? Number(object.plate) : 0, + plateColor: isSet(object.plateColor) ? Number(object.plateColor) : 0, + plateNumber: isSet(object.plateNumber) ? Number(object.plateNumber) : 0, + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + title: isSet(object.title) ? String(object.title) : "", + level: isSet(object.level) ? Number(object.level) : 0, + windowSticker: isSet(object.windowSticker) + ? Boolean(object.windowSticker) + : false, + windowStickerString: isSet(object.windowStickerString) + ? String(object.windowStickerString) + : "", + windowStickerFont: isSet(object.windowStickerFont) + ? Number(object.windowStickerFont) + : 0, + windowDecoration: isSet(object.windowDecoration) + ? Number(object.windowDecoration) + : 0, + rivalMarker: isSet(object.rivalMarker) ? Number(object.rivalMarker) : 0, + lastPlayedAt: isSet(object.lastPlayedAt) + ? Number(object.lastPlayedAt) + : 0, + lastPlayedPlace: isSet(object.lastPlayedPlace) + ? Place.fromJSON(object.lastPlayedPlace) + : undefined, + aura: isSet(object.aura) ? Number(object.aura) : 0, + auraMotif: isSet(object.auraMotif) ? Number(object.auraMotif) : 0, + ghostLevel: isSet(object.ghostLevel) ? Number(object.ghostLevel) : 0, + country: isSet(object.country) ? String(object.country) : "", + searchCode: isSet(object.searchCode) ? String(object.searchCode) : "", + }; + }, + + toJSON(message: Car): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.userId !== undefined && (obj.userId = Math.round(message.userId)); + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + message.name !== undefined && (obj.name = message.name); + message.manufacturer !== undefined && + (obj.manufacturer = Math.round(message.manufacturer)); + message.model !== undefined && (obj.model = Math.round(message.model)); + message.visualModel !== undefined && + (obj.visualModel = Math.round(message.visualModel)); + message.defaultColor !== undefined && + (obj.defaultColor = Math.round(message.defaultColor)); + message.customColor !== undefined && + (obj.customColor = Math.round(message.customColor)); + message.wheel !== undefined && (obj.wheel = Math.round(message.wheel)); + message.wheelColor !== undefined && + (obj.wheelColor = Math.round(message.wheelColor)); + message.aero !== undefined && (obj.aero = Math.round(message.aero)); + message.bonnet !== undefined && (obj.bonnet = Math.round(message.bonnet)); + message.wing !== undefined && (obj.wing = Math.round(message.wing)); + message.gtWing !== undefined && + (obj.gtWing = message.gtWing ? GTWing.toJSON(message.gtWing) : undefined); + message.mirror !== undefined && (obj.mirror = Math.round(message.mirror)); + message.neon !== undefined && (obj.neon = Math.round(message.neon)); + message.trunk !== undefined && (obj.trunk = Math.round(message.trunk)); + message.plate !== undefined && (obj.plate = Math.round(message.plate)); + message.plateColor !== undefined && + (obj.plateColor = Math.round(message.plateColor)); + message.plateNumber !== undefined && + (obj.plateNumber = Math.round(message.plateNumber)); + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.title !== undefined && (obj.title = message.title); + message.level !== undefined && (obj.level = Math.round(message.level)); + message.windowSticker !== undefined && + (obj.windowSticker = message.windowSticker); + message.windowStickerString !== undefined && + (obj.windowStickerString = message.windowStickerString); + message.windowStickerFont !== undefined && + (obj.windowStickerFont = Math.round(message.windowStickerFont)); + message.windowDecoration !== undefined && + (obj.windowDecoration = Math.round(message.windowDecoration)); + message.rivalMarker !== undefined && + (obj.rivalMarker = Math.round(message.rivalMarker)); + message.lastPlayedAt !== undefined && + (obj.lastPlayedAt = Math.round(message.lastPlayedAt)); + message.lastPlayedPlace !== undefined && + (obj.lastPlayedPlace = message.lastPlayedPlace + ? Place.toJSON(message.lastPlayedPlace) + : undefined); + message.aura !== undefined && (obj.aura = Math.round(message.aura)); + message.auraMotif !== undefined && + (obj.auraMotif = Math.round(message.auraMotif)); + message.ghostLevel !== undefined && + (obj.ghostLevel = Math.round(message.ghostLevel)); + message.country !== undefined && (obj.country = message.country); + message.searchCode !== undefined && (obj.searchCode = message.searchCode); + return obj; + }, + + fromPartial, I>>(object: I): Car { + const message = createBaseCar(); + message.carId = object.carId ?? 0; + message.userId = object.userId ?? 0; + message.regionId = object.regionId ?? 0; + message.name = object.name ?? ""; + message.manufacturer = object.manufacturer ?? 0; + message.model = object.model ?? 0; + message.visualModel = object.visualModel ?? 0; + message.defaultColor = object.defaultColor ?? 0; + message.customColor = object.customColor ?? 0; + message.wheel = object.wheel ?? 0; + message.wheelColor = object.wheelColor ?? 0; + message.aero = object.aero ?? 0; + message.bonnet = object.bonnet ?? 0; + message.wing = object.wing ?? 0; + message.gtWing = + object.gtWing !== undefined && object.gtWing !== null + ? GTWing.fromPartial(object.gtWing) + : undefined; + message.mirror = object.mirror ?? 0; + message.neon = object.neon ?? 0; + message.trunk = object.trunk ?? 0; + message.plate = object.plate ?? 0; + message.plateColor = object.plateColor ?? 0; + message.plateNumber = object.plateNumber ?? 0; + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.title = object.title ?? ""; + message.level = object.level ?? 0; + message.windowSticker = object.windowSticker ?? false; + message.windowStickerString = object.windowStickerString ?? ""; + message.windowStickerFont = object.windowStickerFont ?? 0; + message.windowDecoration = object.windowDecoration ?? 0; + message.rivalMarker = object.rivalMarker ?? 0; + message.lastPlayedAt = object.lastPlayedAt ?? 0; + message.lastPlayedPlace = + object.lastPlayedPlace !== undefined && object.lastPlayedPlace !== null + ? Place.fromPartial(object.lastPlayedPlace) + : undefined; + message.aura = object.aura ?? 0; + message.auraMotif = object.auraMotif ?? 0; + message.ghostLevel = object.ghostLevel ?? 0; + message.country = object.country ?? ""; + message.searchCode = object.searchCode ?? ""; + return message; + }, +}; + +function createBaseCarSetting(): CarSetting { + return { + carId: 0, + view: false, + transmission: false, + retire: false, + meter: 0, + navigationMap: false, + volume: 0, + bgm: 0, + nameplate: 0, + nameplateColor: 0, + terminalBackground: 0, + }; +} + +export const CarSetting = { + encode( + message: CarSetting, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.view === true) { + writer.uint32(16).bool(message.view); + } + if (message.transmission === true) { + writer.uint32(24).bool(message.transmission); + } + if (message.retire === true) { + writer.uint32(32).bool(message.retire); + } + if (message.meter !== 0) { + writer.uint32(40).uint32(message.meter); + } + if (message.navigationMap === true) { + writer.uint32(48).bool(message.navigationMap); + } + if (message.volume !== 0) { + writer.uint32(56).uint32(message.volume); + } + if (message.bgm !== 0) { + writer.uint32(64).uint32(message.bgm); + } + if (message.nameplate !== 0) { + writer.uint32(72).uint32(message.nameplate); + } + if (message.nameplateColor !== 0) { + writer.uint32(80).uint32(message.nameplateColor); + } + if (message.terminalBackground !== 0) { + writer.uint32(104).uint32(message.terminalBackground); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CarSetting { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCarSetting(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.view = reader.bool(); + break; + case 3: + message.transmission = reader.bool(); + break; + case 4: + message.retire = reader.bool(); + break; + case 5: + message.meter = reader.uint32(); + break; + case 6: + message.navigationMap = reader.bool(); + break; + case 7: + message.volume = reader.uint32(); + break; + case 8: + message.bgm = reader.uint32(); + break; + case 9: + message.nameplate = reader.uint32(); + break; + case 10: + message.nameplateColor = reader.uint32(); + break; + case 13: + message.terminalBackground = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CarSetting { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + view: isSet(object.view) ? Boolean(object.view) : false, + transmission: isSet(object.transmission) + ? Boolean(object.transmission) + : false, + retire: isSet(object.retire) ? Boolean(object.retire) : false, + meter: isSet(object.meter) ? Number(object.meter) : 0, + navigationMap: isSet(object.navigationMap) + ? Boolean(object.navigationMap) + : false, + volume: isSet(object.volume) ? Number(object.volume) : 0, + bgm: isSet(object.bgm) ? Number(object.bgm) : 0, + nameplate: isSet(object.nameplate) ? Number(object.nameplate) : 0, + nameplateColor: isSet(object.nameplateColor) + ? Number(object.nameplateColor) + : 0, + terminalBackground: isSet(object.terminalBackground) + ? Number(object.terminalBackground) + : 0, + }; + }, + + toJSON(message: CarSetting): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.view !== undefined && (obj.view = message.view); + message.transmission !== undefined && + (obj.transmission = message.transmission); + message.retire !== undefined && (obj.retire = message.retire); + message.meter !== undefined && (obj.meter = Math.round(message.meter)); + message.navigationMap !== undefined && + (obj.navigationMap = message.navigationMap); + message.volume !== undefined && (obj.volume = Math.round(message.volume)); + message.bgm !== undefined && (obj.bgm = Math.round(message.bgm)); + message.nameplate !== undefined && + (obj.nameplate = Math.round(message.nameplate)); + message.nameplateColor !== undefined && + (obj.nameplateColor = Math.round(message.nameplateColor)); + message.terminalBackground !== undefined && + (obj.terminalBackground = Math.round(message.terminalBackground)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CarSetting { + const message = createBaseCarSetting(); + message.carId = object.carId ?? 0; + message.view = object.view ?? false; + message.transmission = object.transmission ?? false; + message.retire = object.retire ?? false; + message.meter = object.meter ?? 0; + message.navigationMap = object.navigationMap ?? false; + message.volume = object.volume ?? 0; + message.bgm = object.bgm ?? 0; + message.nameplate = object.nameplate ?? 0; + message.nameplateColor = object.nameplateColor ?? 0; + message.terminalBackground = object.terminalBackground ?? 0; + return message; + }, +}; + +function createBaseGTWing(): GTWing { + return { + pillar: 0, + pillarMaterial: 0, + mainWing: 0, + mainWingColor: 0, + wingTip: 0, + material: 0, + }; +} + +export const GTWing = { + encode( + message: GTWing, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.pillar !== 0) { + writer.uint32(8).uint32(message.pillar); + } + if (message.pillarMaterial !== 0) { + writer.uint32(16).uint32(message.pillarMaterial); + } + if (message.mainWing !== 0) { + writer.uint32(24).uint32(message.mainWing); + } + if (message.mainWingColor !== 0) { + writer.uint32(32).uint32(message.mainWingColor); + } + if (message.wingTip !== 0) { + writer.uint32(40).uint32(message.wingTip); + } + if (message.material !== 0) { + writer.uint32(48).uint32(message.material); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GTWing { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGTWing(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pillar = reader.uint32(); + break; + case 2: + message.pillarMaterial = reader.uint32(); + break; + case 3: + message.mainWing = reader.uint32(); + break; + case 4: + message.mainWingColor = reader.uint32(); + break; + case 5: + message.wingTip = reader.uint32(); + break; + case 6: + message.material = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GTWing { + return { + pillar: isSet(object.pillar) ? Number(object.pillar) : 0, + pillarMaterial: isSet(object.pillarMaterial) + ? Number(object.pillarMaterial) + : 0, + mainWing: isSet(object.mainWing) ? Number(object.mainWing) : 0, + mainWingColor: isSet(object.mainWingColor) + ? Number(object.mainWingColor) + : 0, + wingTip: isSet(object.wingTip) ? Number(object.wingTip) : 0, + material: isSet(object.material) ? Number(object.material) : 0, + }; + }, + + toJSON(message: GTWing): unknown { + const obj: any = {}; + message.pillar !== undefined && (obj.pillar = Math.round(message.pillar)); + message.pillarMaterial !== undefined && + (obj.pillarMaterial = Math.round(message.pillarMaterial)); + message.mainWing !== undefined && + (obj.mainWing = Math.round(message.mainWing)); + message.mainWingColor !== undefined && + (obj.mainWingColor = Math.round(message.mainWingColor)); + message.wingTip !== undefined && + (obj.wingTip = Math.round(message.wingTip)); + message.material !== undefined && + (obj.material = Math.round(message.material)); + return obj; + }, + + fromPartial, I>>(object: I): GTWing { + const message = createBaseGTWing(); + message.pillar = object.pillar ?? 0; + message.pillarMaterial = object.pillarMaterial ?? 0; + message.mainWing = object.mainWing ?? 0; + message.mainWingColor = object.mainWingColor ?? 0; + message.wingTip = object.wingTip ?? 0; + message.material = object.material ?? 0; + return message; + }, +}; + +function createBaseCarItem(): CarItem { + return { category: 1, itemId: 0, amount: 0 }; +} + +export const CarItem = { + encode( + message: CarItem, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.category !== 1) { + writer.uint32(8).int32(message.category); + } + if (message.itemId !== 0) { + writer.uint32(16).uint32(message.itemId); + } + if (message.amount !== 0) { + writer.uint32(24).uint32(message.amount); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CarItem { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCarItem(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.category = reader.int32() as any; + break; + case 2: + message.itemId = reader.uint32(); + break; + case 3: + message.amount = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CarItem { + return { + category: isSet(object.category) + ? itemCategoryFromJSON(object.category) + : 1, + itemId: isSet(object.itemId) ? Number(object.itemId) : 0, + amount: isSet(object.amount) ? Number(object.amount) : 0, + }; + }, + + toJSON(message: CarItem): unknown { + const obj: any = {}; + message.category !== undefined && + (obj.category = itemCategoryToJSON(message.category)); + message.itemId !== undefined && (obj.itemId = Math.round(message.itemId)); + message.amount !== undefined && (obj.amount = Math.round(message.amount)); + return obj; + }, + + fromPartial, I>>(object: I): CarItem { + const message = createBaseCarItem(); + message.category = object.category ?? 1; + message.itemId = object.itemId ?? 0; + message.amount = object.amount ?? 0; + return message; + }, +}; + +function createBaseCopiedCar(): CopiedCar { + return { car: undefined, remainingPlayCounts: 0 }; +} + +export const CopiedCar = { + encode( + message: CopiedCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.remainingPlayCounts !== 0) { + writer.uint32(16).uint32(message.remainingPlayCounts); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CopiedCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCopiedCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.remainingPlayCounts = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CopiedCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + remainingPlayCounts: isSet(object.remainingPlayCounts) + ? Number(object.remainingPlayCounts) + : 0, + }; + }, + + toJSON(message: CopiedCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.remainingPlayCounts !== undefined && + (obj.remainingPlayCounts = Math.round(message.remainingPlayCounts)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CopiedCar { + const message = createBaseCopiedCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.remainingPlayCounts = object.remainingPlayCounts ?? 0; + return message; + }, +}; + +function createBaseFriendCar(): FriendCar { + return { car: undefined, friendshipLevel: 0, nonhuman: false }; +} + +export const FriendCar = { + encode( + message: FriendCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.friendshipLevel !== 0) { + writer.uint32(16).uint32(message.friendshipLevel); + } + if (message.nonhuman === true) { + writer.uint32(24).bool(message.nonhuman); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): FriendCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFriendCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.friendshipLevel = reader.uint32(); + break; + case 3: + message.nonhuman = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): FriendCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + friendshipLevel: isSet(object.friendshipLevel) + ? Number(object.friendshipLevel) + : 0, + nonhuman: isSet(object.nonhuman) ? Boolean(object.nonhuman) : false, + }; + }, + + toJSON(message: FriendCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.friendshipLevel !== undefined && + (obj.friendshipLevel = Math.round(message.friendshipLevel)); + message.nonhuman !== undefined && (obj.nonhuman = message.nonhuman); + return obj; + }, + + fromPartial, I>>( + object: I + ): FriendCar { + const message = createBaseFriendCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.friendshipLevel = object.friendshipLevel ?? 0; + message.nonhuman = object.nonhuman ?? false; + return message; + }, +}; + +function createBaseChallengerCar(): ChallengerCar { + return { car: undefined, stamp: 0, result: 0, area: 0 }; +} + +export const ChallengerCar = { + encode( + message: ChallengerCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.stamp !== 0) { + writer.uint32(24).uint32(message.stamp); + } + if (message.result !== 0) { + writer.uint32(32).sint32(message.result); + } + if (message.area !== 0) { + writer.uint32(40).uint32(message.area); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): ChallengerCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseChallengerCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 3: + message.stamp = reader.uint32(); + break; + case 4: + message.result = reader.sint32(); + break; + case 5: + message.area = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ChallengerCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + stamp: isSet(object.stamp) ? Number(object.stamp) : 0, + result: isSet(object.result) ? Number(object.result) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + }; + }, + + toJSON(message: ChallengerCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.stamp !== undefined && (obj.stamp = Math.round(message.stamp)); + message.result !== undefined && (obj.result = Math.round(message.result)); + message.area !== undefined && (obj.area = Math.round(message.area)); + return obj; + }, + + fromPartial, I>>( + object: I + ): ChallengerCar { + const message = createBaseChallengerCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.stamp = object.stamp ?? 0; + message.result = object.result ?? 0; + message.area = object.area ?? 0; + return message; + }, +}; + +function createBaseStampTargetCar(): StampTargetCar { + return { car: undefined, returnCount: 0, locked: false, recommended: false }; +} + +export const StampTargetCar = { + encode( + message: StampTargetCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.returnCount !== 0) { + writer.uint32(16).uint32(message.returnCount); + } + if (message.locked === true) { + writer.uint32(24).bool(message.locked); + } + if (message.recommended === true) { + writer.uint32(32).bool(message.recommended); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): StampTargetCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStampTargetCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.returnCount = reader.uint32(); + break; + case 3: + message.locked = reader.bool(); + break; + case 4: + message.recommended = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): StampTargetCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + returnCount: isSet(object.returnCount) ? Number(object.returnCount) : 0, + locked: isSet(object.locked) ? Boolean(object.locked) : false, + recommended: isSet(object.recommended) + ? Boolean(object.recommended) + : false, + }; + }, + + toJSON(message: StampTargetCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.returnCount !== undefined && + (obj.returnCount = Math.round(message.returnCount)); + message.locked !== undefined && (obj.locked = message.locked); + message.recommended !== undefined && + (obj.recommended = message.recommended); + return obj; + }, + + fromPartial, I>>( + object: I + ): StampTargetCar { + const message = createBaseStampTargetCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.returnCount = object.returnCount ?? 0; + message.locked = object.locked ?? false; + message.recommended = object.recommended ?? false; + return message; + }, +}; + +function createBaseBookmarkedCar(): BookmarkedCar { + return { car: undefined, returnCount: 0 }; +} + +export const BookmarkedCar = { + encode( + message: BookmarkedCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.returnCount !== 0) { + writer.uint32(16).uint32(message.returnCount); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): BookmarkedCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBookmarkedCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.returnCount = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): BookmarkedCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + returnCount: isSet(object.returnCount) ? Number(object.returnCount) : 0, + }; + }, + + toJSON(message: BookmarkedCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.returnCount !== undefined && + (obj.returnCount = Math.round(message.returnCount)); + return obj; + }, + + fromPartial, I>>( + object: I + ): BookmarkedCar { + const message = createBaseBookmarkedCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.returnCount = object.returnCount ?? 0; + return message; + }, +}; + +function createBasePreviousVersionStampTargetCar(): PreviousVersionStampTargetCar { + return { car: undefined, returnCount: 0, currentCarId: 0 }; +} + +export const PreviousVersionStampTargetCar = { + encode( + message: PreviousVersionStampTargetCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.returnCount !== 0) { + writer.uint32(24).uint32(message.returnCount); + } + if (message.currentCarId !== 0) { + writer.uint32(16).uint32(message.currentCarId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): PreviousVersionStampTargetCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePreviousVersionStampTargetCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 3: + message.returnCount = reader.uint32(); + break; + case 2: + message.currentCarId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): PreviousVersionStampTargetCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + returnCount: isSet(object.returnCount) ? Number(object.returnCount) : 0, + currentCarId: isSet(object.currentCarId) + ? Number(object.currentCarId) + : 0, + }; + }, + + toJSON(message: PreviousVersionStampTargetCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.returnCount !== undefined && + (obj.returnCount = Math.round(message.returnCount)); + message.currentCarId !== undefined && + (obj.currentCarId = Math.round(message.currentCarId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): PreviousVersionStampTargetCar { + const message = createBasePreviousVersionStampTargetCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.returnCount = object.returnCount ?? 0; + message.currentCarId = object.currentCarId ?? 0; + return message; + }, +}; + +function createBaseGhostCar(): GhostCar { + return { + car: undefined, + area: 0, + ramp: 0, + path: 0, + nonhuman: false, + type: 1, + trailId: 0, + }; +} + +export const GhostCar = { + encode( + message: GhostCar, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.car !== undefined) { + Car.encode(message.car, writer.uint32(10).fork()).ldelim(); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + if (message.ramp !== 0) { + writer.uint32(24).uint32(message.ramp); + } + if (message.path !== 0) { + writer.uint32(64).uint32(message.path); + } + if (message.nonhuman === true) { + writer.uint32(32).bool(message.nonhuman); + } + if (message.type !== 1) { + writer.uint32(48).int32(message.type); + } + if (message.trailId !== 0) { + writer.uint32(56).uint64(message.trailId); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GhostCar { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostCar(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.car = Car.decode(reader, reader.uint32()); + break; + case 2: + message.area = reader.uint32(); + break; + case 3: + message.ramp = reader.uint32(); + break; + case 8: + message.path = reader.uint32(); + break; + case 4: + message.nonhuman = reader.bool(); + break; + case 6: + message.type = reader.int32() as any; + break; + case 7: + message.trailId = longToNumber(reader.uint64() as Long); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostCar { + return { + car: isSet(object.car) ? Car.fromJSON(object.car) : undefined, + area: isSet(object.area) ? Number(object.area) : 0, + ramp: isSet(object.ramp) ? Number(object.ramp) : 0, + path: isSet(object.path) ? Number(object.path) : 0, + nonhuman: isSet(object.nonhuman) ? Boolean(object.nonhuman) : false, + type: isSet(object.type) ? ghostTypeFromJSON(object.type) : 1, + trailId: isSet(object.trailId) ? Number(object.trailId) : 0, + }; + }, + + toJSON(message: GhostCar): unknown { + const obj: any = {}; + message.car !== undefined && + (obj.car = message.car ? Car.toJSON(message.car) : undefined); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.ramp !== undefined && (obj.ramp = Math.round(message.ramp)); + message.path !== undefined && (obj.path = Math.round(message.path)); + message.nonhuman !== undefined && (obj.nonhuman = message.nonhuman); + message.type !== undefined && (obj.type = ghostTypeToJSON(message.type)); + message.trailId !== undefined && + (obj.trailId = Math.round(message.trailId)); + return obj; + }, + + fromPartial, I>>(object: I): GhostCar { + const message = createBaseGhostCar(); + message.car = + object.car !== undefined && object.car !== null + ? Car.fromPartial(object.car) + : undefined; + message.area = object.area ?? 0; + message.ramp = object.ramp ?? 0; + message.path = object.path ?? 0; + message.nonhuman = object.nonhuman ?? false; + message.type = object.type ?? 1; + message.trailId = object.trailId ?? 0; + return message; + }, +}; + +function createBasePlace(): Place { + return { placeId: "", shopName: "", regionId: 0, country: "" }; +} + +export const Place = { + encode(message: Place, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.placeId !== "") { + writer.uint32(10).string(message.placeId); + } + if (message.shopName !== "") { + writer.uint32(18).string(message.shopName); + } + if (message.regionId !== 0) { + writer.uint32(24).uint32(message.regionId); + } + if (message.country !== "") { + writer.uint32(34).string(message.country); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Place { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePlace(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.placeId = reader.string(); + break; + case 2: + message.shopName = reader.string(); + break; + case 3: + message.regionId = reader.uint32(); + break; + case 4: + message.country = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Place { + return { + placeId: isSet(object.placeId) ? String(object.placeId) : "", + shopName: isSet(object.shopName) ? String(object.shopName) : "", + regionId: isSet(object.regionId) ? Number(object.regionId) : 0, + country: isSet(object.country) ? String(object.country) : "", + }; + }, + + toJSON(message: Place): unknown { + const obj: any = {}; + message.placeId !== undefined && (obj.placeId = message.placeId); + message.shopName !== undefined && (obj.shopName = message.shopName); + message.regionId !== undefined && + (obj.regionId = Math.round(message.regionId)); + message.country !== undefined && (obj.country = message.country); + return obj; + }, + + fromPartial, I>>(object: I): Place { + const message = createBasePlace(); + message.placeId = object.placeId ?? ""; + message.shopName = object.shopName ?? ""; + message.regionId = object.regionId ?? 0; + message.country = object.country ?? ""; + return message; + }, +}; + +function createBaseSystemSetting(): SystemSetting { + return { + mCoinChute: 0, + mBuyCardCost: 0, + mGameCost: 0, + mContinueCost: 0, + mFullCourseCost: 0, + mFreePlay: false, + mPcbId: 0, + mIcCardRw: false, + mIcCardVender: false, + mMgCardRw: false, + mForceFeedback: false, + mWinsAndRemains: false, + mEventMode: 0, + mEventModeDist: false, + mCloseType: 0, + mCloseSun: 0, + mCloseMon: 0, + mCloseTue: 0, + mCloseWed: 0, + mCloseThu: 0, + mCloseFri: 0, + mCloseSat: 0, + mCloseDay: 0, + mTouchPanel: false, + mGameVol: 0, + mAttractVol: 0, + mCalibHandleCenter: 0, + mCalibAccelCenter: 0, + mCalibBrakeCenter: 0, + mCalibTouchLeft: 0, + mCalibTouchRight: 0, + mCalibTouchTop: 0, + mCalibTouchBottom: 0, + }; +} + +export const SystemSetting = { + encode( + message: SystemSetting, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.mCoinChute !== 0) { + writer.uint32(8).uint32(message.mCoinChute); + } + if (message.mBuyCardCost !== 0) { + writer.uint32(16).uint32(message.mBuyCardCost); + } + if (message.mGameCost !== 0) { + writer.uint32(24).uint32(message.mGameCost); + } + if (message.mContinueCost !== 0) { + writer.uint32(32).uint32(message.mContinueCost); + } + if (message.mFullCourseCost !== 0) { + writer.uint32(40).uint32(message.mFullCourseCost); + } + if (message.mFreePlay === true) { + writer.uint32(48).bool(message.mFreePlay); + } + if (message.mPcbId !== 0) { + writer.uint32(56).uint32(message.mPcbId); + } + if (message.mIcCardRw === true) { + writer.uint32(64).bool(message.mIcCardRw); + } + if (message.mIcCardVender === true) { + writer.uint32(72).bool(message.mIcCardVender); + } + if (message.mMgCardRw === true) { + writer.uint32(80).bool(message.mMgCardRw); + } + if (message.mForceFeedback === true) { + writer.uint32(88).bool(message.mForceFeedback); + } + if (message.mWinsAndRemains === true) { + writer.uint32(96).bool(message.mWinsAndRemains); + } + if (message.mEventMode !== 0) { + writer.uint32(104).uint32(message.mEventMode); + } + if (message.mEventModeDist === true) { + writer.uint32(112).bool(message.mEventModeDist); + } + if (message.mCloseType !== 0) { + writer.uint32(120).uint32(message.mCloseType); + } + if (message.mCloseSun !== 0) { + writer.uint32(128).uint32(message.mCloseSun); + } + if (message.mCloseMon !== 0) { + writer.uint32(136).uint32(message.mCloseMon); + } + if (message.mCloseTue !== 0) { + writer.uint32(144).uint32(message.mCloseTue); + } + if (message.mCloseWed !== 0) { + writer.uint32(152).uint32(message.mCloseWed); + } + if (message.mCloseThu !== 0) { + writer.uint32(160).uint32(message.mCloseThu); + } + if (message.mCloseFri !== 0) { + writer.uint32(168).uint32(message.mCloseFri); + } + if (message.mCloseSat !== 0) { + writer.uint32(176).uint32(message.mCloseSat); + } + if (message.mCloseDay !== 0) { + writer.uint32(184).uint32(message.mCloseDay); + } + if (message.mTouchPanel === true) { + writer.uint32(192).bool(message.mTouchPanel); + } + if (message.mGameVol !== 0) { + writer.uint32(200).uint32(message.mGameVol); + } + if (message.mAttractVol !== 0) { + writer.uint32(208).uint32(message.mAttractVol); + } + if (message.mCalibHandleCenter !== 0) { + writer.uint32(216).uint32(message.mCalibHandleCenter); + } + if (message.mCalibAccelCenter !== 0) { + writer.uint32(224).uint32(message.mCalibAccelCenter); + } + if (message.mCalibBrakeCenter !== 0) { + writer.uint32(232).uint32(message.mCalibBrakeCenter); + } + if (message.mCalibTouchLeft !== 0) { + writer.uint32(240).uint32(message.mCalibTouchLeft); + } + if (message.mCalibTouchRight !== 0) { + writer.uint32(248).uint32(message.mCalibTouchRight); + } + if (message.mCalibTouchTop !== 0) { + writer.uint32(256).uint32(message.mCalibTouchTop); + } + if (message.mCalibTouchBottom !== 0) { + writer.uint32(264).uint32(message.mCalibTouchBottom); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): SystemSetting { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSystemSetting(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.mCoinChute = reader.uint32(); + break; + case 2: + message.mBuyCardCost = reader.uint32(); + break; + case 3: + message.mGameCost = reader.uint32(); + break; + case 4: + message.mContinueCost = reader.uint32(); + break; + case 5: + message.mFullCourseCost = reader.uint32(); + break; + case 6: + message.mFreePlay = reader.bool(); + break; + case 7: + message.mPcbId = reader.uint32(); + break; + case 8: + message.mIcCardRw = reader.bool(); + break; + case 9: + message.mIcCardVender = reader.bool(); + break; + case 10: + message.mMgCardRw = reader.bool(); + break; + case 11: + message.mForceFeedback = reader.bool(); + break; + case 12: + message.mWinsAndRemains = reader.bool(); + break; + case 13: + message.mEventMode = reader.uint32(); + break; + case 14: + message.mEventModeDist = reader.bool(); + break; + case 15: + message.mCloseType = reader.uint32(); + break; + case 16: + message.mCloseSun = reader.uint32(); + break; + case 17: + message.mCloseMon = reader.uint32(); + break; + case 18: + message.mCloseTue = reader.uint32(); + break; + case 19: + message.mCloseWed = reader.uint32(); + break; + case 20: + message.mCloseThu = reader.uint32(); + break; + case 21: + message.mCloseFri = reader.uint32(); + break; + case 22: + message.mCloseSat = reader.uint32(); + break; + case 23: + message.mCloseDay = reader.uint32(); + break; + case 24: + message.mTouchPanel = reader.bool(); + break; + case 25: + message.mGameVol = reader.uint32(); + break; + case 26: + message.mAttractVol = reader.uint32(); + break; + case 27: + message.mCalibHandleCenter = reader.uint32(); + break; + case 28: + message.mCalibAccelCenter = reader.uint32(); + break; + case 29: + message.mCalibBrakeCenter = reader.uint32(); + break; + case 30: + message.mCalibTouchLeft = reader.uint32(); + break; + case 31: + message.mCalibTouchRight = reader.uint32(); + break; + case 32: + message.mCalibTouchTop = reader.uint32(); + break; + case 33: + message.mCalibTouchBottom = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SystemSetting { + return { + mCoinChute: isSet(object.mCoinChute) ? Number(object.mCoinChute) : 0, + mBuyCardCost: isSet(object.mBuyCardCost) + ? Number(object.mBuyCardCost) + : 0, + mGameCost: isSet(object.mGameCost) ? Number(object.mGameCost) : 0, + mContinueCost: isSet(object.mContinueCost) + ? Number(object.mContinueCost) + : 0, + mFullCourseCost: isSet(object.mFullCourseCost) + ? Number(object.mFullCourseCost) + : 0, + mFreePlay: isSet(object.mFreePlay) ? Boolean(object.mFreePlay) : false, + mPcbId: isSet(object.mPcbId) ? Number(object.mPcbId) : 0, + mIcCardRw: isSet(object.mIcCardRw) ? Boolean(object.mIcCardRw) : false, + mIcCardVender: isSet(object.mIcCardVender) + ? Boolean(object.mIcCardVender) + : false, + mMgCardRw: isSet(object.mMgCardRw) ? Boolean(object.mMgCardRw) : false, + mForceFeedback: isSet(object.mForceFeedback) + ? Boolean(object.mForceFeedback) + : false, + mWinsAndRemains: isSet(object.mWinsAndRemains) + ? Boolean(object.mWinsAndRemains) + : false, + mEventMode: isSet(object.mEventMode) ? Number(object.mEventMode) : 0, + mEventModeDist: isSet(object.mEventModeDist) + ? Boolean(object.mEventModeDist) + : false, + mCloseType: isSet(object.mCloseType) ? Number(object.mCloseType) : 0, + mCloseSun: isSet(object.mCloseSun) ? Number(object.mCloseSun) : 0, + mCloseMon: isSet(object.mCloseMon) ? Number(object.mCloseMon) : 0, + mCloseTue: isSet(object.mCloseTue) ? Number(object.mCloseTue) : 0, + mCloseWed: isSet(object.mCloseWed) ? Number(object.mCloseWed) : 0, + mCloseThu: isSet(object.mCloseThu) ? Number(object.mCloseThu) : 0, + mCloseFri: isSet(object.mCloseFri) ? Number(object.mCloseFri) : 0, + mCloseSat: isSet(object.mCloseSat) ? Number(object.mCloseSat) : 0, + mCloseDay: isSet(object.mCloseDay) ? Number(object.mCloseDay) : 0, + mTouchPanel: isSet(object.mTouchPanel) + ? Boolean(object.mTouchPanel) + : false, + mGameVol: isSet(object.mGameVol) ? Number(object.mGameVol) : 0, + mAttractVol: isSet(object.mAttractVol) ? Number(object.mAttractVol) : 0, + mCalibHandleCenter: isSet(object.mCalibHandleCenter) + ? Number(object.mCalibHandleCenter) + : 0, + mCalibAccelCenter: isSet(object.mCalibAccelCenter) + ? Number(object.mCalibAccelCenter) + : 0, + mCalibBrakeCenter: isSet(object.mCalibBrakeCenter) + ? Number(object.mCalibBrakeCenter) + : 0, + mCalibTouchLeft: isSet(object.mCalibTouchLeft) + ? Number(object.mCalibTouchLeft) + : 0, + mCalibTouchRight: isSet(object.mCalibTouchRight) + ? Number(object.mCalibTouchRight) + : 0, + mCalibTouchTop: isSet(object.mCalibTouchTop) + ? Number(object.mCalibTouchTop) + : 0, + mCalibTouchBottom: isSet(object.mCalibTouchBottom) + ? Number(object.mCalibTouchBottom) + : 0, + }; + }, + + toJSON(message: SystemSetting): unknown { + const obj: any = {}; + message.mCoinChute !== undefined && + (obj.mCoinChute = Math.round(message.mCoinChute)); + message.mBuyCardCost !== undefined && + (obj.mBuyCardCost = Math.round(message.mBuyCardCost)); + message.mGameCost !== undefined && + (obj.mGameCost = Math.round(message.mGameCost)); + message.mContinueCost !== undefined && + (obj.mContinueCost = Math.round(message.mContinueCost)); + message.mFullCourseCost !== undefined && + (obj.mFullCourseCost = Math.round(message.mFullCourseCost)); + message.mFreePlay !== undefined && (obj.mFreePlay = message.mFreePlay); + message.mPcbId !== undefined && (obj.mPcbId = Math.round(message.mPcbId)); + message.mIcCardRw !== undefined && (obj.mIcCardRw = message.mIcCardRw); + message.mIcCardVender !== undefined && + (obj.mIcCardVender = message.mIcCardVender); + message.mMgCardRw !== undefined && (obj.mMgCardRw = message.mMgCardRw); + message.mForceFeedback !== undefined && + (obj.mForceFeedback = message.mForceFeedback); + message.mWinsAndRemains !== undefined && + (obj.mWinsAndRemains = message.mWinsAndRemains); + message.mEventMode !== undefined && + (obj.mEventMode = Math.round(message.mEventMode)); + message.mEventModeDist !== undefined && + (obj.mEventModeDist = message.mEventModeDist); + message.mCloseType !== undefined && + (obj.mCloseType = Math.round(message.mCloseType)); + message.mCloseSun !== undefined && + (obj.mCloseSun = Math.round(message.mCloseSun)); + message.mCloseMon !== undefined && + (obj.mCloseMon = Math.round(message.mCloseMon)); + message.mCloseTue !== undefined && + (obj.mCloseTue = Math.round(message.mCloseTue)); + message.mCloseWed !== undefined && + (obj.mCloseWed = Math.round(message.mCloseWed)); + message.mCloseThu !== undefined && + (obj.mCloseThu = Math.round(message.mCloseThu)); + message.mCloseFri !== undefined && + (obj.mCloseFri = Math.round(message.mCloseFri)); + message.mCloseSat !== undefined && + (obj.mCloseSat = Math.round(message.mCloseSat)); + message.mCloseDay !== undefined && + (obj.mCloseDay = Math.round(message.mCloseDay)); + message.mTouchPanel !== undefined && + (obj.mTouchPanel = message.mTouchPanel); + message.mGameVol !== undefined && + (obj.mGameVol = Math.round(message.mGameVol)); + message.mAttractVol !== undefined && + (obj.mAttractVol = Math.round(message.mAttractVol)); + message.mCalibHandleCenter !== undefined && + (obj.mCalibHandleCenter = Math.round(message.mCalibHandleCenter)); + message.mCalibAccelCenter !== undefined && + (obj.mCalibAccelCenter = Math.round(message.mCalibAccelCenter)); + message.mCalibBrakeCenter !== undefined && + (obj.mCalibBrakeCenter = Math.round(message.mCalibBrakeCenter)); + message.mCalibTouchLeft !== undefined && + (obj.mCalibTouchLeft = Math.round(message.mCalibTouchLeft)); + message.mCalibTouchRight !== undefined && + (obj.mCalibTouchRight = Math.round(message.mCalibTouchRight)); + message.mCalibTouchTop !== undefined && + (obj.mCalibTouchTop = Math.round(message.mCalibTouchTop)); + message.mCalibTouchBottom !== undefined && + (obj.mCalibTouchBottom = Math.round(message.mCalibTouchBottom)); + return obj; + }, + + fromPartial, I>>( + object: I + ): SystemSetting { + const message = createBaseSystemSetting(); + message.mCoinChute = object.mCoinChute ?? 0; + message.mBuyCardCost = object.mBuyCardCost ?? 0; + message.mGameCost = object.mGameCost ?? 0; + message.mContinueCost = object.mContinueCost ?? 0; + message.mFullCourseCost = object.mFullCourseCost ?? 0; + message.mFreePlay = object.mFreePlay ?? false; + message.mPcbId = object.mPcbId ?? 0; + message.mIcCardRw = object.mIcCardRw ?? false; + message.mIcCardVender = object.mIcCardVender ?? false; + message.mMgCardRw = object.mMgCardRw ?? false; + message.mForceFeedback = object.mForceFeedback ?? false; + message.mWinsAndRemains = object.mWinsAndRemains ?? false; + message.mEventMode = object.mEventMode ?? 0; + message.mEventModeDist = object.mEventModeDist ?? false; + message.mCloseType = object.mCloseType ?? 0; + message.mCloseSun = object.mCloseSun ?? 0; + message.mCloseMon = object.mCloseMon ?? 0; + message.mCloseTue = object.mCloseTue ?? 0; + message.mCloseWed = object.mCloseWed ?? 0; + message.mCloseThu = object.mCloseThu ?? 0; + message.mCloseFri = object.mCloseFri ?? 0; + message.mCloseSat = object.mCloseSat ?? 0; + message.mCloseDay = object.mCloseDay ?? 0; + message.mTouchPanel = object.mTouchPanel ?? false; + message.mGameVol = object.mGameVol ?? 0; + message.mAttractVol = object.mAttractVol ?? 0; + message.mCalibHandleCenter = object.mCalibHandleCenter ?? 0; + message.mCalibAccelCenter = object.mCalibAccelCenter ?? 0; + message.mCalibBrakeCenter = object.mCalibBrakeCenter ?? 0; + message.mCalibTouchLeft = object.mCalibTouchLeft ?? 0; + message.mCalibTouchRight = object.mCalibTouchRight ?? 0; + message.mCalibTouchTop = object.mCalibTouchTop ?? 0; + message.mCalibTouchBottom = object.mCalibTouchBottom ?? 0; + return message; + }, +}; + +function createBaseGhostCompetitionSchedule(): GhostCompetitionSchedule { + return { + competitionId: 0, + qualifyingPeriodStartAt: 0, + qualifyingPeriodCloseAt: 0, + competitionStartAt: 0, + competitionCloseAt: 0, + competitionEndAt: 0, + lengthOfPeriod: 0, + lengthOfInterval: 0, + area: 0, + minigamePatternId: 0, + }; +} + +export const GhostCompetitionSchedule = { + encode( + message: GhostCompetitionSchedule, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.competitionId !== 0) { + writer.uint32(8).uint32(message.competitionId); + } + if (message.qualifyingPeriodStartAt !== 0) { + writer.uint32(16).uint32(message.qualifyingPeriodStartAt); + } + if (message.qualifyingPeriodCloseAt !== 0) { + writer.uint32(24).uint32(message.qualifyingPeriodCloseAt); + } + if (message.competitionStartAt !== 0) { + writer.uint32(32).uint32(message.competitionStartAt); + } + if (message.competitionCloseAt !== 0) { + writer.uint32(40).uint32(message.competitionCloseAt); + } + if (message.competitionEndAt !== 0) { + writer.uint32(48).uint32(message.competitionEndAt); + } + if (message.lengthOfPeriod !== 0) { + writer.uint32(56).uint32(message.lengthOfPeriod); + } + if (message.lengthOfInterval !== 0) { + writer.uint32(64).uint32(message.lengthOfInterval); + } + if (message.area !== 0) { + writer.uint32(72).uint32(message.area); + } + if (message.minigamePatternId !== 0) { + writer.uint32(80).uint32(message.minigamePatternId); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): GhostCompetitionSchedule { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostCompetitionSchedule(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.competitionId = reader.uint32(); + break; + case 2: + message.qualifyingPeriodStartAt = reader.uint32(); + break; + case 3: + message.qualifyingPeriodCloseAt = reader.uint32(); + break; + case 4: + message.competitionStartAt = reader.uint32(); + break; + case 5: + message.competitionCloseAt = reader.uint32(); + break; + case 6: + message.competitionEndAt = reader.uint32(); + break; + case 7: + message.lengthOfPeriod = reader.uint32(); + break; + case 8: + message.lengthOfInterval = reader.uint32(); + break; + case 9: + message.area = reader.uint32(); + break; + case 10: + message.minigamePatternId = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostCompetitionSchedule { + return { + competitionId: isSet(object.competitionId) + ? Number(object.competitionId) + : 0, + qualifyingPeriodStartAt: isSet(object.qualifyingPeriodStartAt) + ? Number(object.qualifyingPeriodStartAt) + : 0, + qualifyingPeriodCloseAt: isSet(object.qualifyingPeriodCloseAt) + ? Number(object.qualifyingPeriodCloseAt) + : 0, + competitionStartAt: isSet(object.competitionStartAt) + ? Number(object.competitionStartAt) + : 0, + competitionCloseAt: isSet(object.competitionCloseAt) + ? Number(object.competitionCloseAt) + : 0, + competitionEndAt: isSet(object.competitionEndAt) + ? Number(object.competitionEndAt) + : 0, + lengthOfPeriod: isSet(object.lengthOfPeriod) + ? Number(object.lengthOfPeriod) + : 0, + lengthOfInterval: isSet(object.lengthOfInterval) + ? Number(object.lengthOfInterval) + : 0, + area: isSet(object.area) ? Number(object.area) : 0, + minigamePatternId: isSet(object.minigamePatternId) + ? Number(object.minigamePatternId) + : 0, + }; + }, + + toJSON(message: GhostCompetitionSchedule): unknown { + const obj: any = {}; + message.competitionId !== undefined && + (obj.competitionId = Math.round(message.competitionId)); + message.qualifyingPeriodStartAt !== undefined && + (obj.qualifyingPeriodStartAt = Math.round( + message.qualifyingPeriodStartAt + )); + message.qualifyingPeriodCloseAt !== undefined && + (obj.qualifyingPeriodCloseAt = Math.round( + message.qualifyingPeriodCloseAt + )); + message.competitionStartAt !== undefined && + (obj.competitionStartAt = Math.round(message.competitionStartAt)); + message.competitionCloseAt !== undefined && + (obj.competitionCloseAt = Math.round(message.competitionCloseAt)); + message.competitionEndAt !== undefined && + (obj.competitionEndAt = Math.round(message.competitionEndAt)); + message.lengthOfPeriod !== undefined && + (obj.lengthOfPeriod = Math.round(message.lengthOfPeriod)); + message.lengthOfInterval !== undefined && + (obj.lengthOfInterval = Math.round(message.lengthOfInterval)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.minigamePatternId !== undefined && + (obj.minigamePatternId = Math.round(message.minigamePatternId)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostCompetitionSchedule { + const message = createBaseGhostCompetitionSchedule(); + message.competitionId = object.competitionId ?? 0; + message.qualifyingPeriodStartAt = object.qualifyingPeriodStartAt ?? 0; + message.qualifyingPeriodCloseAt = object.qualifyingPeriodCloseAt ?? 0; + message.competitionStartAt = object.competitionStartAt ?? 0; + message.competitionCloseAt = object.competitionCloseAt ?? 0; + message.competitionEndAt = object.competitionEndAt ?? 0; + message.lengthOfPeriod = object.lengthOfPeriod ?? 0; + message.lengthOfInterval = object.lengthOfInterval ?? 0; + message.area = object.area ?? 0; + message.minigamePatternId = object.minigamePatternId ?? 0; + return message; + }, +}; + +function createBaseGhostCompetitionParameter(): GhostCompetitionParameter { + return { parameters1: [], parameters2: false }; +} + +export const GhostCompetitionParameter = { + encode( + message: GhostCompetitionParameter, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + writer.uint32(10).fork(); + for (const v of message.parameters1) { + writer.float(v); + } + writer.ldelim(); + if (message.parameters2 === true) { + writer.uint32(16).bool(message.parameters2); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): GhostCompetitionParameter { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostCompetitionParameter(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.parameters1.push(reader.float()); + } + } else { + message.parameters1.push(reader.float()); + } + break; + case 2: + message.parameters2 = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostCompetitionParameter { + return { + parameters1: Array.isArray(object?.parameters1) + ? object.parameters1.map((e: any) => Number(e)) + : [], + parameters2: isSet(object.parameters2) + ? Boolean(object.parameters2) + : false, + }; + }, + + toJSON(message: GhostCompetitionParameter): unknown { + const obj: any = {}; + if (message.parameters1) { + obj.parameters1 = message.parameters1.map((e) => e); + } else { + obj.parameters1 = []; + } + message.parameters2 !== undefined && + (obj.parameters2 = message.parameters2); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostCompetitionParameter { + const message = createBaseGhostCompetitionParameter(); + message.parameters1 = object.parameters1?.map((e) => e) || []; + message.parameters2 = object.parameters2 ?? false; + return message; + }, +}; + +function createBaseTransferNotice(): TransferNotice { + return { + needToSeeTransferred: false, + totalMaxiGold: 0, + numOfPorscheCars: 0, + porscheModels: [], + hasR35: false, + }; +} + +export const TransferNotice = { + encode( + message: TransferNotice, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.needToSeeTransferred === true) { + writer.uint32(8).bool(message.needToSeeTransferred); + } + if (message.totalMaxiGold !== 0) { + writer.uint32(16).uint32(message.totalMaxiGold); + } + if (message.numOfPorscheCars !== 0) { + writer.uint32(24).uint32(message.numOfPorscheCars); + } + writer.uint32(34).fork(); + for (const v of message.porscheModels) { + writer.uint32(v); + } + writer.ldelim(); + if (message.hasR35 === true) { + writer.uint32(40).bool(message.hasR35); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): TransferNotice { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTransferNotice(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.needToSeeTransferred = reader.bool(); + break; + case 2: + message.totalMaxiGold = reader.uint32(); + break; + case 3: + message.numOfPorscheCars = reader.uint32(); + break; + case 4: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.porscheModels.push(reader.uint32()); + } + } else { + message.porscheModels.push(reader.uint32()); + } + break; + case 5: + message.hasR35 = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): TransferNotice { + return { + needToSeeTransferred: isSet(object.needToSeeTransferred) + ? Boolean(object.needToSeeTransferred) + : false, + totalMaxiGold: isSet(object.totalMaxiGold) + ? Number(object.totalMaxiGold) + : 0, + numOfPorscheCars: isSet(object.numOfPorscheCars) + ? Number(object.numOfPorscheCars) + : 0, + porscheModels: Array.isArray(object?.porscheModels) + ? object.porscheModels.map((e: any) => Number(e)) + : [], + hasR35: isSet(object.hasR35) ? Boolean(object.hasR35) : false, + }; + }, + + toJSON(message: TransferNotice): unknown { + const obj: any = {}; + message.needToSeeTransferred !== undefined && + (obj.needToSeeTransferred = message.needToSeeTransferred); + message.totalMaxiGold !== undefined && + (obj.totalMaxiGold = Math.round(message.totalMaxiGold)); + message.numOfPorscheCars !== undefined && + (obj.numOfPorscheCars = Math.round(message.numOfPorscheCars)); + if (message.porscheModels) { + obj.porscheModels = message.porscheModels.map((e) => Math.round(e)); + } else { + obj.porscheModels = []; + } + message.hasR35 !== undefined && (obj.hasR35 = message.hasR35); + return obj; + }, + + fromPartial, I>>( + object: I + ): TransferNotice { + const message = createBaseTransferNotice(); + message.needToSeeTransferred = object.needToSeeTransferred ?? false; + message.totalMaxiGold = object.totalMaxiGold ?? 0; + message.numOfPorscheCars = object.numOfPorscheCars ?? 0; + message.porscheModels = object.porscheModels?.map((e) => e) || []; + message.hasR35 = object.hasR35 ?? false; + return message; + }, +}; + +function createBaseGameFeatureVersion(): GameFeatureVersion { + return { version: 0, year: 0, month: 0, pluses: 0, releaseAt: 0 }; +} + +export const GameFeatureVersion = { + encode( + message: GameFeatureVersion, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.version !== 0) { + writer.uint32(8).uint32(message.version); + } + if (message.year !== 0) { + writer.uint32(16).uint32(message.year); + } + if (message.month !== 0) { + writer.uint32(24).uint32(message.month); + } + if (message.pluses !== 0) { + writer.uint32(32).uint32(message.pluses); + } + if (message.releaseAt !== 0) { + writer.uint32(40).uint32(message.releaseAt); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GameFeatureVersion { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGameFeatureVersion(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.version = reader.uint32(); + break; + case 2: + message.year = reader.uint32(); + break; + case 3: + message.month = reader.uint32(); + break; + case 4: + message.pluses = reader.uint32(); + break; + case 5: + message.releaseAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GameFeatureVersion { + return { + version: isSet(object.version) ? Number(object.version) : 0, + year: isSet(object.year) ? Number(object.year) : 0, + month: isSet(object.month) ? Number(object.month) : 0, + pluses: isSet(object.pluses) ? Number(object.pluses) : 0, + releaseAt: isSet(object.releaseAt) ? Number(object.releaseAt) : 0, + }; + }, + + toJSON(message: GameFeatureVersion): unknown { + const obj: any = {}; + message.version !== undefined && + (obj.version = Math.round(message.version)); + message.year !== undefined && (obj.year = Math.round(message.year)); + message.month !== undefined && (obj.month = Math.round(message.month)); + message.pluses !== undefined && (obj.pluses = Math.round(message.pluses)); + message.releaseAt !== undefined && + (obj.releaseAt = Math.round(message.releaseAt)); + return obj; + }, + + fromPartial, I>>( + object: I + ): GameFeatureVersion { + const message = createBaseGameFeatureVersion(); + message.version = object.version ?? 0; + message.year = object.year ?? 0; + message.month = object.month ?? 0; + message.pluses = object.pluses ?? 0; + message.releaseAt = object.releaseAt ?? 0; + return message; + }, +}; + +function createBaseScratchSheet(): ScratchSheet { + return { squares: [] }; +} + +export const ScratchSheet = { + encode( + message: ScratchSheet, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.squares) { + ScratchSheet_ScratchSquare.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): ScratchSheet { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseScratchSheet(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.squares.push( + ScratchSheet_ScratchSquare.decode(reader, reader.uint32()) + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ScratchSheet { + return { + squares: Array.isArray(object?.squares) + ? object.squares.map((e: any) => ScratchSheet_ScratchSquare.fromJSON(e)) + : [], + }; + }, + + toJSON(message: ScratchSheet): unknown { + const obj: any = {}; + if (message.squares) { + obj.squares = message.squares.map((e) => + e ? ScratchSheet_ScratchSquare.toJSON(e) : undefined + ); + } else { + obj.squares = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): ScratchSheet { + const message = createBaseScratchSheet(); + message.squares = + object.squares?.map((e) => ScratchSheet_ScratchSquare.fromPartial(e)) || + []; + return message; + }, +}; + +function createBaseScratchSheet_ScratchSquare(): ScratchSheet_ScratchSquare { + return { category: 1, itemId: 0, earned: false }; +} + +export const ScratchSheet_ScratchSquare = { + encode( + message: ScratchSheet_ScratchSquare, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.category !== 1) { + writer.uint32(8).int32(message.category); + } + if (message.itemId !== 0) { + writer.uint32(16).uint32(message.itemId); + } + if (message.earned === true) { + writer.uint32(24).bool(message.earned); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): ScratchSheet_ScratchSquare { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseScratchSheet_ScratchSquare(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.category = reader.int32() as any; + break; + case 2: + message.itemId = reader.uint32(); + break; + case 3: + message.earned = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ScratchSheet_ScratchSquare { + return { + category: isSet(object.category) + ? itemCategoryFromJSON(object.category) + : 1, + itemId: isSet(object.itemId) ? Number(object.itemId) : 0, + earned: isSet(object.earned) ? Boolean(object.earned) : false, + }; + }, + + toJSON(message: ScratchSheet_ScratchSquare): unknown { + const obj: any = {}; + message.category !== undefined && + (obj.category = itemCategoryToJSON(message.category)); + message.itemId !== undefined && (obj.itemId = Math.round(message.itemId)); + message.earned !== undefined && (obj.earned = message.earned); + return obj; + }, + + fromPartial, I>>( + object: I + ): ScratchSheet_ScratchSquare { + const message = createBaseScratchSheet_ScratchSquare(); + message.category = object.category ?? 1; + message.itemId = object.itemId ?? 0; + message.earned = object.earned ?? false; + return message; + }, +}; + +function createBaseUserItem(): UserItem { + return { category: 1, itemId: 0, userItemId: 0, earnedAt: 0, expireAt: 0 }; +} + +export const UserItem = { + encode( + message: UserItem, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.category !== 1) { + writer.uint32(8).int32(message.category); + } + if (message.itemId !== 0) { + writer.uint32(16).uint32(message.itemId); + } + if (message.userItemId !== 0) { + writer.uint32(24).uint32(message.userItemId); + } + if (message.earnedAt !== 0) { + writer.uint32(32).uint32(message.earnedAt); + } + if (message.expireAt !== 0) { + writer.uint32(40).uint32(message.expireAt); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): UserItem { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUserItem(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.category = reader.int32() as any; + break; + case 2: + message.itemId = reader.uint32(); + break; + case 3: + message.userItemId = reader.uint32(); + break; + case 4: + message.earnedAt = reader.uint32(); + break; + case 5: + message.expireAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UserItem { + return { + category: isSet(object.category) + ? itemCategoryFromJSON(object.category) + : 1, + itemId: isSet(object.itemId) ? Number(object.itemId) : 0, + userItemId: isSet(object.userItemId) ? Number(object.userItemId) : 0, + earnedAt: isSet(object.earnedAt) ? Number(object.earnedAt) : 0, + expireAt: isSet(object.expireAt) ? Number(object.expireAt) : 0, + }; + }, + + toJSON(message: UserItem): unknown { + const obj: any = {}; + message.category !== undefined && + (obj.category = itemCategoryToJSON(message.category)); + message.itemId !== undefined && (obj.itemId = Math.round(message.itemId)); + message.userItemId !== undefined && + (obj.userItemId = Math.round(message.userItemId)); + message.earnedAt !== undefined && + (obj.earnedAt = Math.round(message.earnedAt)); + message.expireAt !== undefined && + (obj.expireAt = Math.round(message.expireAt)); + return obj; + }, + + fromPartial, I>>(object: I): UserItem { + const message = createBaseUserItem(); + message.category = object.category ?? 1; + message.itemId = object.itemId ?? 0; + message.userItemId = object.userItemId ?? 0; + message.earnedAt = object.earnedAt ?? 0; + message.expireAt = object.expireAt ?? 0; + return message; + }, +}; + +function createBaseInviteFriendCampaignSchedule(): InviteFriendCampaignSchedule { + return { campaignId: 0, startAt: 0, endAt: 0, couponUnreceivableAt: 0 }; +} + +export const InviteFriendCampaignSchedule = { + encode( + message: InviteFriendCampaignSchedule, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.campaignId !== 0) { + writer.uint32(8).uint32(message.campaignId); + } + if (message.startAt !== 0) { + writer.uint32(16).uint32(message.startAt); + } + if (message.endAt !== 0) { + writer.uint32(24).uint32(message.endAt); + } + if (message.couponUnreceivableAt !== 0) { + writer.uint32(32).uint32(message.couponUnreceivableAt); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): InviteFriendCampaignSchedule { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInviteFriendCampaignSchedule(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.campaignId = reader.uint32(); + break; + case 2: + message.startAt = reader.uint32(); + break; + case 3: + message.endAt = reader.uint32(); + break; + case 4: + message.couponUnreceivableAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): InviteFriendCampaignSchedule { + return { + campaignId: isSet(object.campaignId) ? Number(object.campaignId) : 0, + startAt: isSet(object.startAt) ? Number(object.startAt) : 0, + endAt: isSet(object.endAt) ? Number(object.endAt) : 0, + couponUnreceivableAt: isSet(object.couponUnreceivableAt) + ? Number(object.couponUnreceivableAt) + : 0, + }; + }, + + toJSON(message: InviteFriendCampaignSchedule): unknown { + const obj: any = {}; + message.campaignId !== undefined && + (obj.campaignId = Math.round(message.campaignId)); + message.startAt !== undefined && + (obj.startAt = Math.round(message.startAt)); + message.endAt !== undefined && (obj.endAt = Math.round(message.endAt)); + message.couponUnreceivableAt !== undefined && + (obj.couponUnreceivableAt = Math.round(message.couponUnreceivableAt)); + return obj; + }, + + fromPartial, I>>( + object: I + ): InviteFriendCampaignSchedule { + const message = createBaseInviteFriendCampaignSchedule(); + message.campaignId = object.campaignId ?? 0; + message.startAt = object.startAt ?? 0; + message.endAt = object.endAt ?? 0; + message.couponUnreceivableAt = object.couponUnreceivableAt ?? 0; + return message; + }, +}; + +function createBaseCarTuning(): CarTuning { + return { carId: 0, tunePower: 0, tuneHandling: 0, lastPlayedAt: 0 }; +} + +export const CarTuning = { + encode( + message: CarTuning, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.tunePower !== 0) { + writer.uint32(16).uint32(message.tunePower); + } + if (message.tuneHandling !== 0) { + writer.uint32(24).uint32(message.tuneHandling); + } + if (message.lastPlayedAt !== 0) { + writer.uint32(32).uint32(message.lastPlayedAt); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CarTuning { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCarTuning(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.tunePower = reader.uint32(); + break; + case 3: + message.tuneHandling = reader.uint32(); + break; + case 4: + message.lastPlayedAt = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CarTuning { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + tunePower: isSet(object.tunePower) ? Number(object.tunePower) : 0, + tuneHandling: isSet(object.tuneHandling) + ? Number(object.tuneHandling) + : 0, + lastPlayedAt: isSet(object.lastPlayedAt) + ? Number(object.lastPlayedAt) + : 0, + }; + }, + + toJSON(message: CarTuning): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.tunePower !== undefined && + (obj.tunePower = Math.round(message.tunePower)); + message.tuneHandling !== undefined && + (obj.tuneHandling = Math.round(message.tuneHandling)); + message.lastPlayedAt !== undefined && + (obj.lastPlayedAt = Math.round(message.lastPlayedAt)); + return obj; + }, + + fromPartial, I>>( + object: I + ): CarTuning { + const message = createBaseCarTuning(); + message.carId = object.carId ?? 0; + message.tunePower = object.tunePower ?? 0; + message.tuneHandling = object.tuneHandling ?? 0; + message.lastPlayedAt = object.lastPlayedAt ?? 0; + return message; + }, +}; + +function createBaseBinaryData(): BinaryData { + return { data: Buffer.alloc(0), mergeSerial: 0 }; +} + +export const BinaryData = { + encode( + message: BinaryData, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.data.length !== 0) { + writer.uint32(10).bytes(message.data); + } + if (message.mergeSerial !== 0) { + writer.uint32(16).sint32(message.mergeSerial); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): BinaryData { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBinaryData(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.data = reader.bytes() as Buffer; + break; + case 2: + message.mergeSerial = reader.sint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): BinaryData { + return { + data: isSet(object.data) + ? Buffer.from(bytesFromBase64(object.data)) + : Buffer.alloc(0), + mergeSerial: isSet(object.mergeSerial) ? Number(object.mergeSerial) : 0, + }; + }, + + toJSON(message: BinaryData): unknown { + const obj: any = {}; + message.data !== undefined && + (obj.data = base64FromBytes( + message.data !== undefined ? message.data : Buffer.alloc(0) + )); + message.mergeSerial !== undefined && + (obj.mergeSerial = Math.round(message.mergeSerial)); + return obj; + }, + + fromPartial, I>>( + object: I + ): BinaryData { + const message = createBaseBinaryData(); + message.data = object.data ?? Buffer.alloc(0); + message.mergeSerial = object.mergeSerial ?? 0; + return message; + }, +}; + +function createBaseGhostTrail(): GhostTrail { + return { + carId: 0, + area: 0, + ramp: 0, + path: 0, + playedAt: 0, + playedPlace: undefined, + trail: Buffer.alloc(0), + }; +} + +export const GhostTrail = { + encode( + message: GhostTrail, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.carId !== 0) { + writer.uint32(8).uint32(message.carId); + } + if (message.area !== 0) { + writer.uint32(16).uint32(message.area); + } + if (message.ramp !== 0) { + writer.uint32(24).uint32(message.ramp); + } + if (message.path !== 0) { + writer.uint32(56).uint32(message.path); + } + if (message.playedAt !== 0) { + writer.uint32(32).uint32(message.playedAt); + } + if (message.playedPlace !== undefined) { + Place.encode(message.playedPlace, writer.uint32(42).fork()).ldelim(); + } + if (message.trail.length !== 0) { + writer.uint32(50).bytes(message.trail); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GhostTrail { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostTrail(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.carId = reader.uint32(); + break; + case 2: + message.area = reader.uint32(); + break; + case 3: + message.ramp = reader.uint32(); + break; + case 7: + message.path = reader.uint32(); + break; + case 4: + message.playedAt = reader.uint32(); + break; + case 5: + message.playedPlace = Place.decode(reader, reader.uint32()); + break; + case 6: + message.trail = reader.bytes() as Buffer; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostTrail { + return { + carId: isSet(object.carId) ? Number(object.carId) : 0, + area: isSet(object.area) ? Number(object.area) : 0, + ramp: isSet(object.ramp) ? Number(object.ramp) : 0, + path: isSet(object.path) ? Number(object.path) : 0, + playedAt: isSet(object.playedAt) ? Number(object.playedAt) : 0, + playedPlace: isSet(object.playedPlace) + ? Place.fromJSON(object.playedPlace) + : undefined, + trail: isSet(object.trail) + ? Buffer.from(bytesFromBase64(object.trail)) + : Buffer.alloc(0), + }; + }, + + toJSON(message: GhostTrail): unknown { + const obj: any = {}; + message.carId !== undefined && (obj.carId = Math.round(message.carId)); + message.area !== undefined && (obj.area = Math.round(message.area)); + message.ramp !== undefined && (obj.ramp = Math.round(message.ramp)); + message.path !== undefined && (obj.path = Math.round(message.path)); + message.playedAt !== undefined && + (obj.playedAt = Math.round(message.playedAt)); + message.playedPlace !== undefined && + (obj.playedPlace = message.playedPlace + ? Place.toJSON(message.playedPlace) + : undefined); + message.trail !== undefined && + (obj.trail = base64FromBytes( + message.trail !== undefined ? message.trail : Buffer.alloc(0) + )); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostTrail { + const message = createBaseGhostTrail(); + message.carId = object.carId ?? 0; + message.area = object.area ?? 0; + message.ramp = object.ramp ?? 0; + message.path = object.path ?? 0; + message.playedAt = object.playedAt ?? 0; + message.playedPlace = + object.playedPlace !== undefined && object.playedPlace !== null + ? Place.fromPartial(object.playedPlace) + : undefined; + message.trail = object.trail ?? Buffer.alloc(0); + return message; + }, +}; + +function createBasePlaceList(): PlaceList { + return { places: [] }; +} + +export const PlaceList = { + encode( + message: PlaceList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.places) { + Place.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): PlaceList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePlaceList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.places.push(Place.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): PlaceList { + return { + places: Array.isArray(object?.places) + ? object.places.map((e: any) => Place.fromJSON(e)) + : [], + }; + }, + + toJSON(message: PlaceList): unknown { + const obj: any = {}; + if (message.places) { + obj.places = message.places.map((e) => (e ? Place.toJSON(e) : undefined)); + } else { + obj.places = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): PlaceList { + const message = createBasePlaceList(); + message.places = object.places?.map((e) => Place.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseGhostList(): GhostList { + return { ghosts: [] }; +} + +export const GhostList = { + encode( + message: GhostList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.ghosts) { + GhostCar.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GhostList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.ghosts.push(GhostCar.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostList { + return { + ghosts: Array.isArray(object?.ghosts) + ? object.ghosts.map((e: any) => GhostCar.fromJSON(e)) + : [], + }; + }, + + toJSON(message: GhostList): unknown { + const obj: any = {}; + if (message.ghosts) { + obj.ghosts = message.ghosts.map((e) => + e ? GhostCar.toJSON(e) : undefined + ); + } else { + obj.ghosts = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostList { + const message = createBaseGhostList(); + message.ghosts = object.ghosts?.map((e) => GhostCar.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseCarSummary(): CarSummary { + return { hitCount: 0, cars: [] }; +} + +export const CarSummary = { + encode( + message: CarSummary, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.hitCount !== 0) { + writer.uint32(8).uint32(message.hitCount); + } + for (const v of message.cars) { + Car.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CarSummary { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCarSummary(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.hitCount = reader.uint32(); + break; + case 2: + message.cars.push(Car.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CarSummary { + return { + hitCount: isSet(object.hitCount) ? Number(object.hitCount) : 0, + cars: Array.isArray(object?.cars) + ? object.cars.map((e: any) => Car.fromJSON(e)) + : [], + }; + }, + + toJSON(message: CarSummary): unknown { + const obj: any = {}; + message.hitCount !== undefined && + (obj.hitCount = Math.round(message.hitCount)); + if (message.cars) { + obj.cars = message.cars.map((e) => (e ? Car.toJSON(e) : undefined)); + } else { + obj.cars = []; + } + return obj; + }, + + fromPartial, I>>( + object: I + ): CarSummary { + const message = createBaseCarSummary(); + message.hitCount = object.hitCount ?? 0; + message.cars = object.cars?.map((e) => Car.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseFileList(): FileList { + return { files: [], interval: 0 }; +} + +export const FileList = { + encode( + message: FileList, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + for (const v of message.files) { + FileList_FileInfo.encode(v!, writer.uint32(10).fork()).ldelim(); + } + if (message.interval !== 0) { + writer.uint32(16).uint32(message.interval); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): FileList { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFileList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.files.push(FileList_FileInfo.decode(reader, reader.uint32())); + break; + case 2: + message.interval = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): FileList { + return { + files: Array.isArray(object?.files) + ? object.files.map((e: any) => FileList_FileInfo.fromJSON(e)) + : [], + interval: isSet(object.interval) ? Number(object.interval) : 0, + }; + }, + + toJSON(message: FileList): unknown { + const obj: any = {}; + if (message.files) { + obj.files = message.files.map((e) => + e ? FileList_FileInfo.toJSON(e) : undefined + ); + } else { + obj.files = []; + } + message.interval !== undefined && + (obj.interval = Math.round(message.interval)); + return obj; + }, + + fromPartial, I>>(object: I): FileList { + const message = createBaseFileList(); + message.files = + object.files?.map((e) => FileList_FileInfo.fromPartial(e)) || []; + message.interval = object.interval ?? 0; + return message; + }, +}; + +function createBaseFileList_FileInfo(): FileList_FileInfo { + return { + fileId: 0, + fileType: 1, + fileSize: 0, + url: "", + sha1sum: Buffer.alloc(0), + notBefore: 0, + notAfter: 0, + }; +} + +export const FileList_FileInfo = { + encode( + message: FileList_FileInfo, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.fileId !== 0) { + writer.uint32(8).uint32(message.fileId); + } + if (message.fileType !== 1) { + writer.uint32(16).int32(message.fileType); + } + if (message.fileSize !== 0) { + writer.uint32(24).uint32(message.fileSize); + } + if (message.url !== "") { + writer.uint32(34).string(message.url); + } + if (message.sha1sum.length !== 0) { + writer.uint32(42).bytes(message.sha1sum); + } + if (message.notBefore !== 0) { + writer.uint32(48).uint32(message.notBefore); + } + if (message.notAfter !== 0) { + writer.uint32(56).uint32(message.notAfter); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): FileList_FileInfo { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFileList_FileInfo(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.fileId = reader.uint32(); + break; + case 2: + message.fileType = reader.int32() as any; + break; + case 3: + message.fileSize = reader.uint32(); + break; + case 4: + message.url = reader.string(); + break; + case 5: + message.sha1sum = reader.bytes() as Buffer; + break; + case 6: + message.notBefore = reader.uint32(); + break; + case 7: + message.notAfter = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): FileList_FileInfo { + return { + fileId: isSet(object.fileId) ? Number(object.fileId) : 0, + fileType: isSet(object.fileType) ? fileTypeFromJSON(object.fileType) : 1, + fileSize: isSet(object.fileSize) ? Number(object.fileSize) : 0, + url: isSet(object.url) ? String(object.url) : "", + sha1sum: isSet(object.sha1sum) + ? Buffer.from(bytesFromBase64(object.sha1sum)) + : Buffer.alloc(0), + notBefore: isSet(object.notBefore) ? Number(object.notBefore) : 0, + notAfter: isSet(object.notAfter) ? Number(object.notAfter) : 0, + }; + }, + + toJSON(message: FileList_FileInfo): unknown { + const obj: any = {}; + message.fileId !== undefined && (obj.fileId = Math.round(message.fileId)); + message.fileType !== undefined && + (obj.fileType = fileTypeToJSON(message.fileType)); + message.fileSize !== undefined && + (obj.fileSize = Math.round(message.fileSize)); + message.url !== undefined && (obj.url = message.url); + message.sha1sum !== undefined && + (obj.sha1sum = base64FromBytes( + message.sha1sum !== undefined ? message.sha1sum : Buffer.alloc(0) + )); + message.notBefore !== undefined && + (obj.notBefore = Math.round(message.notBefore)); + message.notAfter !== undefined && + (obj.notAfter = Math.round(message.notAfter)); + return obj; + }, + + fromPartial, I>>( + object: I + ): FileList_FileInfo { + const message = createBaseFileList_FileInfo(); + message.fileId = object.fileId ?? 0; + message.fileType = object.fileType ?? 1; + message.fileSize = object.fileSize ?? 0; + message.url = object.url ?? ""; + message.sha1sum = object.sha1sum ?? Buffer.alloc(0); + message.notBefore = object.notBefore ?? 0; + message.notAfter = object.notAfter ?? 0; + return message; + }, +}; + +function createBaseGhostCompetitionTarget(): GhostCompetitionTarget { + return { + competitionId: 0, + specialGhostId: 0, + ghostCar: undefined, + trailId: 0, + updatedAt: 0, + competitionSchedule: undefined, + }; +} + +export const GhostCompetitionTarget = { + encode( + message: GhostCompetitionTarget, + writer: _m0.Writer = _m0.Writer.create() + ): _m0.Writer { + if (message.competitionId !== 0) { + writer.uint32(8).uint32(message.competitionId); + } + if (message.specialGhostId !== 0) { + writer.uint32(16).uint32(message.specialGhostId); + } + if (message.ghostCar !== undefined) { + GhostCar.encode(message.ghostCar, writer.uint32(26).fork()).ldelim(); + } + if (message.trailId !== 0) { + writer.uint32(32).uint64(message.trailId); + } + if (message.updatedAt !== 0) { + writer.uint32(40).uint32(message.updatedAt); + } + if (message.competitionSchedule !== undefined) { + GhostCompetitionSchedule.encode( + message.competitionSchedule, + writer.uint32(50).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: _m0.Reader | Uint8Array, + length?: number + ): GhostCompetitionTarget { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGhostCompetitionTarget(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.competitionId = reader.uint32(); + break; + case 2: + message.specialGhostId = reader.uint32(); + break; + case 3: + message.ghostCar = GhostCar.decode(reader, reader.uint32()); + break; + case 4: + message.trailId = longToNumber(reader.uint64() as Long); + break; + case 5: + message.updatedAt = reader.uint32(); + break; + case 6: + message.competitionSchedule = GhostCompetitionSchedule.decode( + reader, + reader.uint32() + ); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): GhostCompetitionTarget { + return { + competitionId: isSet(object.competitionId) + ? Number(object.competitionId) + : 0, + specialGhostId: isSet(object.specialGhostId) + ? Number(object.specialGhostId) + : 0, + ghostCar: isSet(object.ghostCar) + ? GhostCar.fromJSON(object.ghostCar) + : undefined, + trailId: isSet(object.trailId) ? Number(object.trailId) : 0, + updatedAt: isSet(object.updatedAt) ? Number(object.updatedAt) : 0, + competitionSchedule: isSet(object.competitionSchedule) + ? GhostCompetitionSchedule.fromJSON(object.competitionSchedule) + : undefined, + }; + }, + + toJSON(message: GhostCompetitionTarget): unknown { + const obj: any = {}; + message.competitionId !== undefined && + (obj.competitionId = Math.round(message.competitionId)); + message.specialGhostId !== undefined && + (obj.specialGhostId = Math.round(message.specialGhostId)); + message.ghostCar !== undefined && + (obj.ghostCar = message.ghostCar + ? GhostCar.toJSON(message.ghostCar) + : undefined); + message.trailId !== undefined && + (obj.trailId = Math.round(message.trailId)); + message.updatedAt !== undefined && + (obj.updatedAt = Math.round(message.updatedAt)); + message.competitionSchedule !== undefined && + (obj.competitionSchedule = message.competitionSchedule + ? GhostCompetitionSchedule.toJSON(message.competitionSchedule) + : undefined); + return obj; + }, + + fromPartial, I>>( + object: I + ): GhostCompetitionTarget { + const message = createBaseGhostCompetitionTarget(); + message.competitionId = object.competitionId ?? 0; + message.specialGhostId = object.specialGhostId ?? 0; + message.ghostCar = + object.ghostCar !== undefined && object.ghostCar !== null + ? GhostCar.fromPartial(object.ghostCar) + : undefined; + message.trailId = object.trailId ?? 0; + message.updatedAt = object.updatedAt ?? 0; + message.competitionSchedule = + object.competitionSchedule !== undefined && + object.competitionSchedule !== null + ? GhostCompetitionSchedule.fromPartial(object.competitionSchedule) + : undefined; + return message; + }, +}; + +declare var self: any | undefined; +declare var window: any | undefined; +declare var global: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + +const atob: (b64: string) => string = + globalThis.atob || + ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary")); +function bytesFromBase64(b64: string): Uint8Array { + const bin = atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; +} + +const btoa: (bin: string) => string = + globalThis.btoa || + ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64")); +function base64FromBytes(arr: Uint8Array): string { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(String.fromCharCode(byte)); + }); + return btoa(bin.join("")); +} + +type Builtin = + | Date + | Function + | Uint8Array + | string + | number + | boolean + | undefined; + +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +type KeysOfUnion = T extends T ? keyof T : never; +export type Exact = P extends Builtin + ? P + : P & { [K in keyof P]: Exact } & Record< + Exclude>, + never + >; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (_m0.util.Long !== Long) { + _m0.util.Long = Long as any; + _m0.configure(); +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..3187965 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,5 @@ +// Bayshore - a Wangan Midnight Maximum Tune 6 private server. +// Made with love by Luna, and part of Project Asakura. + +import {Express} from 'express'; +import {PrismaClient} from '@prisma/client'; diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..d3bf32b --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,9 @@ +{ + "compilerOptions": { + "sourceMap": true, + "outDir": "dist", + "strict": true, + "lib": ["esnext"], + "esModuleInterop": true + } +} \ No newline at end of file diff --git a/yarn.lock b/yarn.lock new file mode 100644 index 0000000..5bc83df --- /dev/null +++ b/yarn.lock @@ -0,0 +1,1205 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@babel/parser@^7.9.4": + version "7.18.8" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.18.8.tgz#822146080ac9c62dac0823bb3489622e0bc1cbdf" + integrity sha512-RSKRfYX20dyH+elbJK2uqAkVyucL+xXzhqlMD5/ZXx+dAAwpyB7HsvnHe/ZUGOF+xLr5Wx9/JoXVTj6BQE2/oA== + +"@cspotcode/source-map-support@^0.8.0": + version "0.8.1" + resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1" + integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw== + dependencies: + "@jridgewell/trace-mapping" "0.3.9" + +"@jridgewell/resolve-uri@^3.0.3": + version "3.1.0" + resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78" + integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w== + +"@jridgewell/sourcemap-codec@^1.4.10": + version "1.4.14" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24" + integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw== + +"@jridgewell/trace-mapping@0.3.9": + version "0.3.9" + resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9" + integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== + dependencies: + "@jridgewell/resolve-uri" "^3.0.3" + "@jridgewell/sourcemap-codec" "^1.4.10" + +"@prisma/client@^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/@prisma/client/-/client-4.0.0.tgz#ed2f46930a1da0d8ae88d7965485973576b04270" + integrity sha512-g1h2OGoRo7anBVQ9Cw3gsbjwPtvf7i0pkGxKeZICtwkvE5CZXW+xZF4FZdmrViYkKaAShbISL0teNpu9ecpf4g== + dependencies: + "@prisma/engines-version" "3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11" + +"@prisma/engines-version@3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11": + version "3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11" + resolved "https://registry.yarnpkg.com/@prisma/engines-version/-/engines-version-3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11.tgz#4b5efe5eee2feef12910e4627a572cd96ed83236" + integrity sha512-PiZhdD624SrYEjyLboI0X7OugNbxUzDJx9v/6ldTKuqNDVUCmRH/Z00XwDi/dgM4FlqOSO+YiUsSiSKjxxG8cw== + +"@prisma/engines@3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11": + version "3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11" + resolved "https://registry.yarnpkg.com/@prisma/engines/-/engines-3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11.tgz#82f0018153cffa05d61422f9c0c7b0479b180f75" + integrity sha512-u/rG4lDHALolWBLr3yebZ+N2qImp3SDMcu7bHNJuRDaYvYEXy/MqfNRNEgd9GoPsXL3gofYf0VzJf2AmCG3YVw== + +"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf" + integrity sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ== + +"@protobufjs/base64@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735" + integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg== + +"@protobufjs/codegen@^2.0.4": + version "2.0.4" + resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb" + integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg== + +"@protobufjs/eventemitter@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70" + integrity sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q== + +"@protobufjs/fetch@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45" + integrity sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ== + dependencies: + "@protobufjs/aspromise" "^1.1.1" + "@protobufjs/inquire" "^1.1.0" + +"@protobufjs/float@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1" + integrity sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ== + +"@protobufjs/inquire@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089" + integrity sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q== + +"@protobufjs/path@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d" + integrity sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA== + +"@protobufjs/pool@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54" + integrity sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw== + +"@protobufjs/utf8@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570" + integrity sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw== + +"@tsconfig/node10@^1.0.7": + version "1.0.9" + resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2" + integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA== + +"@tsconfig/node12@^1.0.7": + version "1.0.11" + resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d" + integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag== + +"@tsconfig/node14@^1.0.0": + version "1.0.3" + resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1" + integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== + +"@tsconfig/node16@^1.0.2": + version "1.0.3" + resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.3.tgz#472eaab5f15c1ffdd7f8628bd4c4f753995ec79e" + integrity sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ== + +"@types/body-parser@*": + version "1.19.2" + resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.2.tgz#aea2059e28b7658639081347ac4fab3de166e6f0" + integrity sha512-ALYone6pm6QmwZoAgeyNksccT9Q4AWZQ6PvfwR37GT6r6FWUPguq6sUmNGSMV2Wr761oQoBxwGGa6DR5o1DC9g== + dependencies: + "@types/connect" "*" + "@types/node" "*" + +"@types/connect@*": + version "3.4.35" + resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.35.tgz#5fcf6ae445e4021d1fc2219a4873cc73a3bb2ad1" + integrity sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ== + dependencies: + "@types/node" "*" + +"@types/express-serve-static-core@^4.17.18": + version "4.17.29" + resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.29.tgz#2a1795ea8e9e9c91b4a4bbe475034b20c1ec711c" + integrity sha512-uMd++6dMKS32EOuw1Uli3e3BPgdLIXmezcfHv7N4c1s3gkhikBplORPpMq3fuWkxncZN1reb16d5n8yhQ80x7Q== + dependencies: + "@types/node" "*" + "@types/qs" "*" + "@types/range-parser" "*" + +"@types/express@^4.17.13": + version "4.17.13" + resolved "https://registry.yarnpkg.com/@types/express/-/express-4.17.13.tgz#a76e2995728999bab51a33fabce1d705a3709034" + integrity sha512-6bSZTPaTIACxn48l50SR+axgrqm6qXFIxrdAKaG6PaJk3+zuUr35hBlgT7vOmJcum+OEaIBLtHV/qloEAFITeA== + dependencies: + "@types/body-parser" "*" + "@types/express-serve-static-core" "^4.17.18" + "@types/qs" "*" + "@types/serve-static" "*" + +"@types/linkify-it@*": + version "3.0.2" + resolved "https://registry.yarnpkg.com/@types/linkify-it/-/linkify-it-3.0.2.tgz#fd2cd2edbaa7eaac7e7f3c1748b52a19143846c9" + integrity sha512-HZQYqbiFVWufzCwexrvh694SOim8z2d+xJl5UNamcvQFejLY/2YUtzXHYi3cHdI7PMlS8ejH2slRAOJQ32aNbA== + +"@types/long@^4.0.1": + version "4.0.2" + resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.2.tgz#b74129719fc8d11c01868010082d483b7545591a" + integrity sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA== + +"@types/markdown-it@^12.2.3": + version "12.2.3" + resolved "https://registry.yarnpkg.com/@types/markdown-it/-/markdown-it-12.2.3.tgz#0d6f6e5e413f8daaa26522904597be3d6cd93b51" + integrity sha512-GKMHFfv3458yYy+v/N8gjufHO6MSZKCOXpZc5GXIWWy8uldwfmPn98vp81gZ5f9SVw8YYBctgfJ22a2d7AOMeQ== + dependencies: + "@types/linkify-it" "*" + "@types/mdurl" "*" + +"@types/mdurl@*": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@types/mdurl/-/mdurl-1.0.2.tgz#e2ce9d83a613bacf284c7be7d491945e39e1f8e9" + integrity sha512-eC4U9MlIcu2q0KQmXszyn5Akca/0jrQmwDRgpAMJai7qBWq4amIQhZyNau4VYGtCeALvW1/NtjzJJ567aZxfKA== + +"@types/mime@^1": + version "1.3.2" + resolved "https://registry.yarnpkg.com/@types/mime/-/mime-1.3.2.tgz#93e25bf9ee75fe0fd80b594bc4feb0e862111b5a" + integrity sha512-YATxVxgRqNH6nHEIsvg6k2Boc1JHI9ZbH5iWFFv/MTkchz3b1ieGDa5T0a9RznNdI0KhVbdbWSN+KWWrQZRxTw== + +"@types/node@*", "@types/node@>=13.7.0", "@types/node@^18.0.3": + version "18.0.3" + resolved "https://registry.yarnpkg.com/@types/node/-/node-18.0.3.tgz#463fc47f13ec0688a33aec75d078a0541a447199" + integrity sha512-HzNRZtp4eepNitP+BD6k2L6DROIDG4Q0fm4x+dwfsr6LGmROENnok75VGw40628xf+iR24WeMFcHuuBDUAzzsQ== + +"@types/object-hash@^1.3.0": + version "1.3.4" + resolved "https://registry.yarnpkg.com/@types/object-hash/-/object-hash-1.3.4.tgz#079ba142be65833293673254831b5e3e847fe58b" + integrity sha512-xFdpkAkikBgqBdG9vIlsqffDV8GpvnPEzs0IUtr1v3BEB97ijsFQ4RXVbUZwjFThhB4MDSTUfvmxUD5PGx0wXA== + +"@types/qs@*": + version "6.9.7" + resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.7.tgz#63bb7d067db107cc1e457c303bc25d511febf6cb" + integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw== + +"@types/range-parser@*": + version "1.2.4" + resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.4.tgz#cd667bcfdd025213aafb7ca5915a932590acdcdc" + integrity sha512-EEhsLsD6UsDM1yFhAvy0Cjr6VwmpMWqFBCb9w07wVugF7w9nfajxLuVmngTIpgS6svCnm6Vaw+MZhoDCKnOfsw== + +"@types/serve-static@*": + version "1.13.10" + resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-1.13.10.tgz#f5e0ce8797d2d7cc5ebeda48a52c96c4fa47a8d9" + integrity sha512-nCkHGI4w7ZgAdNkrEu0bv+4xNV/XDqW+DydknebMOQwkpDGx8G+HTlj7R7ABI8i8nKxVw0wtKPi1D+lPOkh4YQ== + dependencies: + "@types/mime" "^1" + "@types/node" "*" + +accepts@~1.3.8: + version "1.3.8" + resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz#0bf0be125b67014adcb0b0921e62db7bffe16b2e" + integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw== + dependencies: + mime-types "~2.1.34" + negotiator "0.6.3" + +acorn-jsx@^5.3.2: + version "5.3.2" + resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" + integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== + +acorn-walk@^8.1.1: + version "8.2.0" + resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1" + integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA== + +acorn@^8.4.1, acorn@^8.7.1: + version "8.7.1" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30" + integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A== + +ansi-styles@^4.1.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +arg@^4.1.0: + version "4.1.3" + resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089" + integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== + +argparse@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +array-flatten@1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2" + integrity sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg== + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +bluebird@^3.7.2: + version "3.7.2" + resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f" + integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg== + +body-parser@1.20.0: + version "1.20.0" + resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.0.tgz#3de69bd89011c11573d7bfee6a64f11b6bd27cc5" + integrity sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg== + dependencies: + bytes "3.1.2" + content-type "~1.0.4" + debug "2.6.9" + depd "2.0.0" + destroy "1.2.0" + http-errors "2.0.0" + iconv-lite "0.4.24" + on-finished "2.4.1" + qs "6.10.3" + raw-body "2.5.1" + type-is "~1.6.18" + unpipe "1.0.0" + +brace-expansion@^1.1.7: + version "1.1.11" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" + integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + +bytes@3.1.2: + version "3.1.2" + resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5" + integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== + +call-bind@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c" + integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA== + dependencies: + function-bind "^1.1.1" + get-intrinsic "^1.0.2" + +catharsis@^0.9.0: + version "0.9.0" + resolved "https://registry.yarnpkg.com/catharsis/-/catharsis-0.9.0.tgz#40382a168be0e6da308c277d3a2b3eb40c7d2121" + integrity sha512-prMTQVpcns/tzFgFVkVp6ak6RykZyWb3gu8ckUpd6YkTlacOd3DXGJjIpD4Q6zJirizvaiAjSSHlOsA+6sNh2A== + dependencies: + lodash "^4.17.15" + +chalk@^4.0.0: + version "4.1.2" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01" + integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" + integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== + +content-disposition@0.5.4: + version "0.5.4" + resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe" + integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ== + dependencies: + safe-buffer "5.2.1" + +content-type@~1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.4.tgz#e138cc75e040c727b1966fe5e5f8c9aee256fe3b" + integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA== + +cookie-signature@1.0.6: + version "1.0.6" + resolved "https://registry.yarnpkg.com/cookie-signature/-/cookie-signature-1.0.6.tgz#e303a882b342cc3ee8ca513a79999734dab3ae2c" + integrity sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ== + +cookie@0.5.0: + version "0.5.0" + resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.5.0.tgz#d1f5d71adec6558c58f389987c366aa47e994f8b" + integrity sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw== + +create-require@^1.1.0: + version "1.1.1" + resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333" + integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== + +dataloader@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/dataloader/-/dataloader-1.4.0.tgz#bca11d867f5d3f1b9ed9f737bd15970c65dff5c8" + integrity sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw== + +debug@2.6.9: + version "2.6.9" + resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f" + integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== + dependencies: + ms "2.0.0" + +deep-is@~0.1.3: + version "0.1.4" + resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831" + integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== + +depd@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== + +destroy@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015" + integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg== + +diff@^4.0.1: + version "4.0.2" + resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d" + integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== + +ee-first@1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d" + integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow== + +encodeurl@~1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59" + integrity sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w== + +entities@~2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/entities/-/entities-2.1.0.tgz#992d3129cf7df6870b96c57858c249a120f8b8b5" + integrity sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w== + +escape-html@~1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988" + integrity sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow== + +escape-string-regexp@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344" + integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== + +escodegen@^1.13.0: + version "1.14.3" + resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.14.3.tgz#4e7b81fba61581dc97582ed78cab7f0e8d63f503" + integrity sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw== + dependencies: + esprima "^4.0.1" + estraverse "^4.2.0" + esutils "^2.0.2" + optionator "^0.8.1" + optionalDependencies: + source-map "~0.6.1" + +eslint-visitor-keys@^3.3.0: + version "3.3.0" + resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826" + integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA== + +espree@^9.0.0: + version "9.3.2" + resolved "https://registry.yarnpkg.com/espree/-/espree-9.3.2.tgz#f58f77bd334731182801ced3380a8cc859091596" + integrity sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA== + dependencies: + acorn "^8.7.1" + acorn-jsx "^5.3.2" + eslint-visitor-keys "^3.3.0" + +esprima@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +estraverse@^4.2.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d" + integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== + +estraverse@^5.1.0: + version "5.3.0" + resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123" + integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== + +esutils@^2.0.2: + version "2.0.3" + resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64" + integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== + +etag@~1.8.1: + version "1.8.1" + resolved "https://registry.yarnpkg.com/etag/-/etag-1.8.1.tgz#41ae2eeb65efa62268aebfea83ac7d79299b0887" + integrity sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg== + +express@^4.18.1: + version "4.18.1" + resolved "https://registry.yarnpkg.com/express/-/express-4.18.1.tgz#7797de8b9c72c857b9cd0e14a5eea80666267caf" + integrity sha512-zZBcOX9TfehHQhtupq57OF8lFZ3UZi08Y97dwFCkD8p9d/d2Y3M+ykKcwaMDEL+4qyUolgBDX6AblpR3fL212Q== + dependencies: + accepts "~1.3.8" + array-flatten "1.1.1" + body-parser "1.20.0" + content-disposition "0.5.4" + content-type "~1.0.4" + cookie "0.5.0" + cookie-signature "1.0.6" + debug "2.6.9" + depd "2.0.0" + encodeurl "~1.0.2" + escape-html "~1.0.3" + etag "~1.8.1" + finalhandler "1.2.0" + fresh "0.5.2" + http-errors "2.0.0" + merge-descriptors "1.0.1" + methods "~1.1.2" + on-finished "2.4.1" + parseurl "~1.3.3" + path-to-regexp "0.1.7" + proxy-addr "~2.0.7" + qs "6.10.3" + range-parser "~1.2.1" + safe-buffer "5.2.1" + send "0.18.0" + serve-static "1.15.0" + setprototypeof "1.2.0" + statuses "2.0.1" + type-is "~1.6.18" + utils-merge "1.0.1" + vary "~1.1.2" + +fast-levenshtein@~2.0.6: + version "2.0.6" + resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" + integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== + +finalhandler@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.2.0.tgz#7d23fe5731b207b4640e4fcd00aec1f9207a7b32" + integrity sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg== + dependencies: + debug "2.6.9" + encodeurl "~1.0.2" + escape-html "~1.0.3" + on-finished "2.4.1" + parseurl "~1.3.3" + statuses "2.0.1" + unpipe "~1.0.0" + +forwarded@0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.2.0.tgz#2269936428aad4c15c7ebe9779a84bf0b2a81811" + integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow== + +fresh@0.5.2: + version "0.5.2" + resolved "https://registry.yarnpkg.com/fresh/-/fresh-0.5.2.tgz#3d8cadd90d976569fa835ab1f8e4b23a105605a7" + integrity sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q== + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" + integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== + +function-bind@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" + integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== + +get-intrinsic@^1.0.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.2.tgz#336975123e05ad0b7ba41f152ee4aadbea6cf598" + integrity sha512-Jfm3OyCxHh9DJyc28qGk+JmfkpO41A4XkneDSujN9MDXrm4oDKdHvndhZ2dN94+ERNfkYJWDclW6k2L/ZGHjXA== + dependencies: + function-bind "^1.1.1" + has "^1.0.3" + has-symbols "^1.0.3" + +glob@^7.1.3: + version "7.2.3" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" + integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.1.1" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@^8.0.0: + version "8.0.3" + resolved "https://registry.yarnpkg.com/glob/-/glob-8.0.3.tgz#415c6eb2deed9e502c68fa44a272e6da6eeca42e" + integrity sha512-ull455NHSHI/Y1FqGaaYFaLGkNMMJbavMrEGFXG/PGrg6y7sutWHUHrz6gy6WEBH6akM1M414dWKCNs+IhKdiQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^5.0.1" + once "^1.3.0" + +has-flag@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" + integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== + +has-symbols@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8" + integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A== + +has@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796" + integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== + dependencies: + function-bind "^1.1.1" + +http-errors@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3" + integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== + dependencies: + depd "2.0.0" + inherits "2.0.4" + setprototypeof "1.2.0" + statuses "2.0.1" + toidentifier "1.0.1" + +iconv-lite@0.4.24: + version "0.4.24" + resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b" + integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== + dependencies: + safer-buffer ">= 2.1.2 < 3" + +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" + integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2, inherits@2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +ipaddr.js@1.9.1: + version "1.9.1" + resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz#bff38543eeb8984825079ff3a2a8e6cbd46781b3" + integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g== + +js2xmlparser@^4.0.2: + version "4.0.2" + resolved "https://registry.yarnpkg.com/js2xmlparser/-/js2xmlparser-4.0.2.tgz#2a1fdf01e90585ef2ae872a01bc169c6a8d5e60a" + integrity sha512-6n4D8gLlLf1n5mNLQPRfViYzu9RATblzPEtm1SthMX1Pjao0r9YI9nw7ZIfRxQMERS87mcswrg+r/OYrPRX6jA== + dependencies: + xmlcreate "^2.0.4" + +jsdoc@^3.6.3: + version "3.6.10" + resolved "https://registry.yarnpkg.com/jsdoc/-/jsdoc-3.6.10.tgz#dc903c44763b78afa7d94d63da475d20bc224cc4" + integrity sha512-IdQ8ppSo5LKZ9o3M+LKIIK8i00DIe5msDvG3G81Km+1dhy0XrOWD0Ji8H61ElgyEj/O9KRLokgKbAM9XX9CJAg== + dependencies: + "@babel/parser" "^7.9.4" + "@types/markdown-it" "^12.2.3" + bluebird "^3.7.2" + catharsis "^0.9.0" + escape-string-regexp "^2.0.0" + js2xmlparser "^4.0.2" + klaw "^4.0.1" + markdown-it "^12.3.2" + markdown-it-anchor "^8.4.1" + marked "^4.0.10" + mkdirp "^1.0.4" + requizzle "^0.2.3" + strip-json-comments "^3.1.0" + taffydb "2.6.2" + underscore "~1.13.2" + +klaw@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/klaw/-/klaw-4.0.1.tgz#8dc6f5723f05894e8e931b516a8ff15c2976d368" + integrity sha512-pgsE40/SvC7st04AHiISNewaIMUbY5V/K8b21ekiPiFoYs/EYSdsGa+FJArB1d441uq4Q8zZyIxvAzkGNlBdRw== + +levn@~0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" + integrity sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA== + dependencies: + prelude-ls "~1.1.2" + type-check "~0.3.2" + +linkify-it@^3.0.1: + version "3.0.3" + resolved "https://registry.yarnpkg.com/linkify-it/-/linkify-it-3.0.3.tgz#a98baf44ce45a550efb4d49c769d07524cc2fa2e" + integrity sha512-ynTsyrFSdE5oZ/O9GEf00kPngmOfVwazR5GKDq6EYfhlpFug3J2zybX56a2PRRpc9P+FuSoGNAwjlbDs9jJBPQ== + dependencies: + uc.micro "^1.0.1" + +lodash@^4.17.14, lodash@^4.17.15: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +long@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/long/-/long-4.0.0.tgz#9a7b71cfb7d361a194ea555241c92f7468d5bf28" + integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA== + +long@^5.0.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/long/-/long-5.2.0.tgz#2696dadf4b4da2ce3f6f6b89186085d94d52fd61" + integrity sha512-9RTUNjK60eJbx3uz+TEGF7fUr29ZDxR5QzXcyDpeSfeH28S9ycINflOgOlppit5U+4kNTe83KQnMEerw7GmE8w== + +lru-cache@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" + integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== + dependencies: + yallist "^4.0.0" + +make-error@^1.1.1: + version "1.3.6" + resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" + integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== + +markdown-it-anchor@^8.4.1: + version "8.6.4" + resolved "https://registry.yarnpkg.com/markdown-it-anchor/-/markdown-it-anchor-8.6.4.tgz#affb8aa0910a504c114e9fcad53ac3a5b907b0e6" + integrity sha512-Ul4YVYZNxMJYALpKtu+ZRdrryYt/GlQ5CK+4l1bp/gWXOG2QWElt6AqF3Mih/wfUKdZbNAZVXGR73/n6U/8img== + +markdown-it@^12.3.2: + version "12.3.2" + resolved "https://registry.yarnpkg.com/markdown-it/-/markdown-it-12.3.2.tgz#bf92ac92283fe983fe4de8ff8abfb5ad72cd0c90" + integrity sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg== + dependencies: + argparse "^2.0.1" + entities "~2.1.0" + linkify-it "^3.0.1" + mdurl "^1.0.1" + uc.micro "^1.0.5" + +marked@^4.0.10: + version "4.0.17" + resolved "https://registry.yarnpkg.com/marked/-/marked-4.0.17.tgz#1186193d85bb7882159cdcfc57d1dfccaffb3fe9" + integrity sha512-Wfk0ATOK5iPxM4ptrORkFemqroz0ZDxp5MWfYA7H/F+wO17NRWV5Ypxi6p3g2Xmw2bKeiYOl6oVnLHKxBA0VhA== + +mdurl@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-1.0.1.tgz#fe85b2ec75a59037f2adfec100fd6c601761152e" + integrity sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g== + +media-typer@0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748" + integrity sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ== + +merge-descriptors@1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/merge-descriptors/-/merge-descriptors-1.0.1.tgz#b00aaa556dd8b44568150ec9d1b953f3f90cbb61" + integrity sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w== + +methods@~1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee" + integrity sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w== + +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== + +mime-types@~2.1.24, mime-types@~2.1.34: + version "2.1.35" + resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== + dependencies: + mime-db "1.52.0" + +mime@1.6.0: + version "1.6.0" + resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1" + integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== + +minimatch@^3.1.1: + version "3.1.2" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== + dependencies: + brace-expansion "^1.1.7" + +minimatch@^5.0.1: + version "5.1.0" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.1.0.tgz#1717b464f4971b144f6aabe8f2d0b8e4511e09c7" + integrity sha512-9TPBGGak4nHfGZsPBohm9AWg6NoT7QTCehS3BIJABslyZbzxfV78QM2Y6+i741OPZIafFAaiiEMh5OyIrJPgtg== + dependencies: + brace-expansion "^2.0.1" + +minimist@^1.2.0: + version "1.2.6" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44" + integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q== + +mkdirp@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + +ms@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8" + integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A== + +ms@2.1.3: + version "2.1.3" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +negotiator@0.6.3: + version "0.6.3" + resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd" + integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg== + +object-hash@^1.3.1: + version "1.3.1" + resolved "https://registry.yarnpkg.com/object-hash/-/object-hash-1.3.1.tgz#fde452098a951cb145f039bb7d455449ddc126df" + integrity sha512-OSuu/pU4ENM9kmREg0BdNrUDIl1heYa4mBZacJc+vVWz4GtAwu7jO8s4AIt2aGRUTqxykpWzI3Oqnsm13tTMDA== + +object-inspect@^1.9.0: + version "1.12.2" + resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.2.tgz#c0641f26394532f28ab8d796ab954e43c009a8ea" + integrity sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ== + +on-finished@2.4.1: + version "2.4.1" + resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f" + integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg== + dependencies: + ee-first "1.1.1" + +once@^1.3.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +optionator@^0.8.1: + version "0.8.3" + resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495" + integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA== + dependencies: + deep-is "~0.1.3" + fast-levenshtein "~2.0.6" + levn "~0.3.0" + prelude-ls "~1.1.2" + type-check "~0.3.2" + word-wrap "~1.2.3" + +parseurl@~1.3.3: + version "1.3.3" + resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4" + integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ== + +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" + integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== + +path-to-regexp@0.1.7: + version "0.1.7" + resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-0.1.7.tgz#df604178005f522f15eb4490e7247a1bfaa67f8c" + integrity sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ== + +prelude-ls@~1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" + integrity sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w== + +prettier@^2.5.1: + version "2.7.1" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.7.1.tgz#e235806850d057f97bb08368a4f7d899f7760c64" + integrity sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g== + +prisma@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/prisma/-/prisma-4.0.0.tgz#4ddb8fcd4f64d33aff8c198a6986dcce66dc8152" + integrity sha512-Dtsar03XpCBkcEb2ooGWO/WcgblDTLzGhPcustbehwlFXuTMliMDRzXsfygsgYwQoZnAUKRd1rhpvBNEUziOVw== + dependencies: + "@prisma/engines" "3.16.0-49.da41d2bb3406da22087b849f0e911199ba4fbf11" + +protobufjs-cli@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/protobufjs-cli/-/protobufjs-cli-1.0.0.tgz#62f99de142118f34c7b4ee53c2dc122612d2711c" + integrity sha512-7NZEBrFuuU2ZdzlhmAmvh8fdU7A4OFhzYX9AB7a5vXjopAeiks6ZgUSjOlOO7ItCDJQm3y9RWjk7spUbHc4X0w== + dependencies: + chalk "^4.0.0" + escodegen "^1.13.0" + espree "^9.0.0" + estraverse "^5.1.0" + glob "^8.0.0" + jsdoc "^3.6.3" + minimist "^1.2.0" + semver "^7.1.2" + tmp "^0.2.1" + uglify-js "^3.7.7" + +protobufjs@^6.11.3, protobufjs@^6.8.8: + version "6.11.3" + resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-6.11.3.tgz#637a527205a35caa4f3e2a9a4a13ddffe0e7af74" + integrity sha512-xL96WDdCZYdU7Slin569tFX712BxsxslWwAfAhCYjQKGTq7dAU91Lomy6nLLhh/dyGhk/YH4TwTSRxTzhuHyZg== + dependencies: + "@protobufjs/aspromise" "^1.1.2" + "@protobufjs/base64" "^1.1.2" + "@protobufjs/codegen" "^2.0.4" + "@protobufjs/eventemitter" "^1.1.0" + "@protobufjs/fetch" "^1.1.0" + "@protobufjs/float" "^1.0.2" + "@protobufjs/inquire" "^1.1.0" + "@protobufjs/path" "^1.1.2" + "@protobufjs/pool" "^1.1.0" + "@protobufjs/utf8" "^1.1.0" + "@types/long" "^4.0.1" + "@types/node" ">=13.7.0" + long "^4.0.0" + +protobufjs@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-7.0.0.tgz#8c678e1351fd926178fce5a4213913e8d990974f" + integrity sha512-ffNIEm+quOcYtQvHdW406v1NQmZSuqVklxsXk076BtuFnlYZfigLU+JOMrTD8TUOyqHYbRI/fSVNvgd25YeN3w== + dependencies: + "@protobufjs/aspromise" "^1.1.2" + "@protobufjs/base64" "^1.1.2" + "@protobufjs/codegen" "^2.0.4" + "@protobufjs/eventemitter" "^1.1.0" + "@protobufjs/fetch" "^1.1.0" + "@protobufjs/float" "^1.0.2" + "@protobufjs/inquire" "^1.1.0" + "@protobufjs/path" "^1.1.2" + "@protobufjs/pool" "^1.1.0" + "@protobufjs/utf8" "^1.1.0" + "@types/long" "^4.0.1" + "@types/node" ">=13.7.0" + long "^5.0.0" + +proxy-addr@~2.0.7: + version "2.0.7" + resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.7.tgz#f19fe69ceab311eeb94b42e70e8c2070f9ba1025" + integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg== + dependencies: + forwarded "0.2.0" + ipaddr.js "1.9.1" + +qs@6.10.3: + version "6.10.3" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.3.tgz#d6cde1b2ffca87b5aa57889816c5f81535e22e8e" + integrity sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ== + dependencies: + side-channel "^1.0.4" + +range-parser@~1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031" + integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg== + +raw-body@2.5.1: + version "2.5.1" + resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.1.tgz#fe1b1628b181b700215e5fd42389f98b71392857" + integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig== + dependencies: + bytes "3.1.2" + http-errors "2.0.0" + iconv-lite "0.4.24" + unpipe "1.0.0" + +requizzle@^0.2.3: + version "0.2.3" + resolved "https://registry.yarnpkg.com/requizzle/-/requizzle-0.2.3.tgz#4675c90aacafb2c036bd39ba2daa4a1cb777fded" + integrity sha512-YanoyJjykPxGHii0fZP0uUPEXpvqfBDxWV7s6GKAiiOsiqhX6vHNyW3Qzdmqp/iq/ExbhaGbVrjB4ruEVSM4GQ== + dependencies: + lodash "^4.17.14" + +rimraf@^3.0.0: + version "3.0.2" + resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" + integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== + dependencies: + glob "^7.1.3" + +safe-buffer@5.2.1: + version "5.2.1" + resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +"safer-buffer@>= 2.1.2 < 3": + version "2.1.2" + resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== + +semver@^7.1.2: + version "7.3.7" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f" + integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g== + dependencies: + lru-cache "^6.0.0" + +send@0.18.0: + version "0.18.0" + resolved "https://registry.yarnpkg.com/send/-/send-0.18.0.tgz#670167cc654b05f5aa4a767f9113bb371bc706be" + integrity sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg== + dependencies: + debug "2.6.9" + depd "2.0.0" + destroy "1.2.0" + encodeurl "~1.0.2" + escape-html "~1.0.3" + etag "~1.8.1" + fresh "0.5.2" + http-errors "2.0.0" + mime "1.6.0" + ms "2.1.3" + on-finished "2.4.1" + range-parser "~1.2.1" + statuses "2.0.1" + +serve-static@1.15.0: + version "1.15.0" + resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.15.0.tgz#faaef08cffe0a1a62f60cad0c4e513cff0ac9540" + integrity sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g== + dependencies: + encodeurl "~1.0.2" + escape-html "~1.0.3" + parseurl "~1.3.3" + send "0.18.0" + +setprototypeof@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424" + integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== + +side-channel@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf" + integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw== + dependencies: + call-bind "^1.0.0" + get-intrinsic "^1.0.2" + object-inspect "^1.9.0" + +source-map@~0.6.1: + version "0.6.1" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" + integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== + +statuses@2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63" + integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== + +strip-json-comments@^3.1.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" + integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== + +supports-color@^7.1.0: + version "7.2.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== + dependencies: + has-flag "^4.0.0" + +taffydb@2.6.2: + version "2.6.2" + resolved "https://registry.yarnpkg.com/taffydb/-/taffydb-2.6.2.tgz#7cbcb64b5a141b6a2efc2c5d2c67b4e150b2a268" + integrity sha512-y3JaeRSplks6NYQuCOj3ZFMO3j60rTwbuKCvZxsAraGYH2epusatvZ0baZYA01WsGqJBq/Dl6vOrMUJqyMj8kA== + +tmp@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14" + integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ== + dependencies: + rimraf "^3.0.0" + +toidentifier@1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35" + integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== + +ts-node@^10.8.2: + version "10.8.2" + resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.8.2.tgz#3185b75228cef116bf82ffe8762594f54b2a23f2" + integrity sha512-LYdGnoGddf1D6v8REPtIH+5iq/gTDuZqv2/UJUU7tKjuEU8xVZorBM+buCGNjj+pGEud+sOoM4CX3/YzINpENA== + dependencies: + "@cspotcode/source-map-support" "^0.8.0" + "@tsconfig/node10" "^1.0.7" + "@tsconfig/node12" "^1.0.7" + "@tsconfig/node14" "^1.0.0" + "@tsconfig/node16" "^1.0.2" + acorn "^8.4.1" + acorn-walk "^8.1.1" + arg "^4.1.0" + create-require "^1.1.0" + diff "^4.0.1" + make-error "^1.1.1" + v8-compile-cache-lib "^3.0.1" + yn "3.1.1" + +ts-poet@^4.15.0: + version "4.15.0" + resolved "https://registry.yarnpkg.com/ts-poet/-/ts-poet-4.15.0.tgz#637145fa554d3b27c56541578df0ce08cd9eb328" + integrity sha512-sLLR8yQBvHzi9d4R1F4pd+AzQxBfzOSSjfxiJxQhkUoH5bL7RsAC6wgvtVUQdGqiCsyS9rT6/8X2FI7ipdir5g== + dependencies: + lodash "^4.17.15" + prettier "^2.5.1" + +ts-proto-descriptors@1.7.1: + version "1.7.1" + resolved "https://registry.yarnpkg.com/ts-proto-descriptors/-/ts-proto-descriptors-1.7.1.tgz#685d00305b06adfa929fd5a016a419382cd64c50" + integrity sha512-oIKUh3K4Xts4v29USGLfUG+2mEk32MsqpgZAOUyUlkrcIdv34yE+k2oZ2Nzngm6cV/JgFdOxRCqeyvmWHuYAyw== + dependencies: + long "^4.0.0" + protobufjs "^6.8.8" + +ts-proto@^1.117.0: + version "1.117.0" + resolved "https://registry.yarnpkg.com/ts-proto/-/ts-proto-1.117.0.tgz#9186c36b7d71153fd65dc8f18c28defe54be65d7" + integrity sha512-htGXhOsq1oZ7T13YeNjpm4xYxniTk+tsdEX2/KQVg+2ycTjMw1POk7gI4B2agp1ABxv+Qwe5/QuLIf8fQQ72dw== + dependencies: + "@types/object-hash" "^1.3.0" + dataloader "^1.4.0" + object-hash "^1.3.1" + protobufjs "^6.11.3" + ts-poet "^4.15.0" + ts-proto-descriptors "1.7.1" + +type-check@~0.3.2: + version "0.3.2" + resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" + integrity sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg== + dependencies: + prelude-ls "~1.1.2" + +type-is@~1.6.18: + version "1.6.18" + resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131" + integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g== + dependencies: + media-typer "0.3.0" + mime-types "~2.1.24" + +typescript@^4.7.4: + version "4.7.4" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.7.4.tgz#1a88596d1cf47d59507a1bcdfb5b9dfe4d488235" + integrity sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ== + +uc.micro@^1.0.1, uc.micro@^1.0.5: + version "1.0.6" + resolved "https://registry.yarnpkg.com/uc.micro/-/uc.micro-1.0.6.tgz#9c411a802a409a91fc6cf74081baba34b24499ac" + integrity sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA== + +uglify-js@^3.7.7: + version "3.16.2" + resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.16.2.tgz#0481e1dbeed343ad1c2ddf3c6d42e89b7a6d4def" + integrity sha512-AaQNokTNgExWrkEYA24BTNMSjyqEXPSfhqoS0AxmHkCJ4U+Dyy5AvbGV/sqxuxficEfGGoX3zWw9R7QpLFfEsg== + +underscore@~1.13.2: + version "1.13.4" + resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.13.4.tgz#7886b46bbdf07f768e0052f1828e1dcab40c0dee" + integrity sha512-BQFnUDuAQ4Yf/cYY5LNrK9NCJFKriaRbD9uR1fTeXnBeoa97W0i41qkZfGO9pSo8I5KzjAcSY2XYtdf0oKd7KQ== + +unpipe@1.0.0, unpipe@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec" + integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ== + +utils-merge@1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713" + integrity sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA== + +v8-compile-cache-lib@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf" + integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== + +vary@~1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc" + integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg== + +word-wrap@~1.2.3: + version "1.2.3" + resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" + integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== + +wrappy@1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== + +xmlcreate@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/xmlcreate/-/xmlcreate-2.0.4.tgz#0c5ab0f99cdd02a81065fa9cd8f8ae87624889be" + integrity sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg== + +yallist@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" + integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== + +yn@3.1.1: + version "3.1.1" + resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50" + integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==