/* 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 extends Exact<DeepPartial<PlaceListQuery>, 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 extends Exact<DeepPartial<GhostListQuery>, 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 extends Exact<DeepPartial<GhostTrailQuery>, 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 extends Exact<DeepPartial<CarSummaryQuery>, 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 extends Exact<DeepPartial<FileListQuery>, 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 extends Exact<DeepPartial<GhostCompetitionTargetQuery>, 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 extends Exact<DeepPartial<LockCrownRequest>, 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 extends Exact<DeepPartial<LockCrownResponse>, 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 extends Exact<DeepPartial<Crown>, 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 extends Exact<DeepPartial<CrownListQuery>, 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 extends Exact<DeepPartial<CrownList>, 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 extends Exact<DeepPartial<RankingQuery>, 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 extends Exact<DeepPartial<Ranking>, 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 extends Exact<DeepPartial<Ranking_List>, 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 extends Exact<DeepPartial<Ranking_Entry>, 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<RegisterSystemInfoResponse>;
  register_system_stats(
    request: RegisterSystemStatsRequest
  ): Promise<RegisterSystemStatsResponse>;
  register_ghost_trail(
    request: RegisterGhostTrailRequest
  ): Promise<RegisterGhostTrailResponse>;
  load_user(request: LoadUserRequest): Promise<LoadUserResponse>;
  update_user_session(
    request: UpdateUserSessionRequest
  ): Promise<UpdateUserSessionResponse>;
  load_drive_information(
    request: LoadDriveInformationRequest
  ): Promise<LoadDriveInformationResponse>;
  load_car(request: LoadCarRequest): Promise<LoadCarResponse>;
  create_car(request: CreateCarRequest): Promise<CreateCarResponse>;
  load_game_history(
    request: LoadGameHistoryRequest
  ): Promise<LoadGameHistoryResponse>;
  update_car(request: UpdateCarRequest): Promise<UpdateCarResponse>;
  save_game_result(
    request: SaveGameResultRequest
  ): Promise<SaveGameResultResponse>;
  save_charge(request: SaveChargeRequest): Promise<SaveChargeResponse>;
  load_ghost_battle_info(
    request: LoadGhostBattleInfoRequest
  ): Promise<LoadGhostBattleInfoResponse>;
  load_stamp_target(
    request: LoadStampTargetRequest
  ): Promise<LoadStampTargetResponse>;
  lock_stamp_target(
    request: LockStampTargetRequest
  ): Promise<LockStampTargetResponse>;
  load_ghost_competition_info(
    request: LoadGhostCompetitionInfoRequest
  ): Promise<LoadGhostCompetitionInfoResponse>;
  load_time_attack_record(
    request: LoadTimeAttackRecordRequest
  ): Promise<LoadTimeAttackRecordResponse>;
  save_terminal_result(
    request: SaveTerminalResultRequest
  ): Promise<SaveTerminalResultResponse>;
  ping(request: PingRequest): Promise<PingResponse>;
  load_terminal_information(
    request: LoadTerminalInformationRequest
  ): Promise<LoadTerminalInformationResponse>;
  create_user(request: CreateUserRequest): Promise<CreateUserResponse>;
  ask_access_code(
    request: AskAccessCodeRequest
  ): Promise<AskAccessCodeResponse>;
  register_opponent_ghost(
    request: RegisterOpponentGhostRequest
  ): Promise<RegisterOpponentGhostResponse>;
  load_bookmarks(request: LoadBookmarksRequest): Promise<LoadBookmarksResponse>;
  save_bookmarks(request: SaveBookmarksRequest): Promise<SaveBookmarksResponse>;
  grant_car_right(
    request: GrantCarRightRequest
  ): Promise<GrantCarRightResponse>;
  load_ghost_competition_ranking(
    request: LoadGhostCompetitionRankingRequest
  ): Promise<LoadGhostCompetitionRankingResponse>;
  load_unreceived_user_items(
    request: LoadUnreceivedUserItemsRequest
  ): Promise<LoadUnreceivedUserItemsResponse>;
  start_transfer(request: StartTransferRequest): Promise<StartTransferResponse>;
  save_screenshot(
    request: SaveScreenshotRequest
  ): Promise<SaveScreenshotResponse>;
  load_scratch_information(
    request: LoadScratchInformationRequest
  ): Promise<LoadScratchInformationResponse>;
  save_scratch_sheet(
    request: SaveScratchSheetRequest
  ): Promise<SaveScratchSheetResponse>;
  turn_scratch_sheet(
    request: TurnScratchSheetRequest
  ): Promise<TurnScratchSheetResponse>;
  check_item_receivable_cars(
    request: CheckItemReceivableCarsRequest
  ): Promise<CheckItemReceivableCarsResponse>;
  receive_user_items(
    request: ReceiveUserItemsRequest
  ): Promise<ReceiveUserItemsResponse>;
  update_event_mode_serial(
    request: UpdateEventModeSerialRequest
  ): Promise<UpdateEventModeSerialResponse>;
  consume_user_item(
    request: ConsumeUserItemRequest
  ): Promise<ConsumeUserItemResponse>;
  search_cars_by_level(
    request: SearchCarsByLevelRequest
  ): Promise<SearchCarsByLevelResponse>;
  load_paths_and_tunings(
    request: LoadPathsAndTuningsRequest
  ): Promise<LoadPathsAndTuningsResponse>;
  load_ghost_drive_data(
    request: LoadGhostDriveDataRequest
  ): Promise<LoadGhostDriveDataResponse>;
  participate_in_invite_friend_campaign(
    request: ParticipateInInviteFriendCampaignRequest
  ): Promise<ParticipateInInviteFriendCampaignResponse>;
  lock_crown(request: LockCrownRequest): Promise<LockCrownResponse>;
  submit_client_log(
    request: SubmitClientLogRequest
  ): Promise<SubmitClientLogResponse>;
}

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<RegisterSystemInfoResponse> {
    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<RegisterSystemStatsResponse> {
    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<RegisterGhostTrailResponse> {
    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<LoadUserResponse> {
    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<UpdateUserSessionResponse> {
    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<LoadDriveInformationResponse> {
    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<LoadCarResponse> {
    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<CreateCarResponse> {
    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<LoadGameHistoryResponse> {
    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<UpdateCarResponse> {
    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<SaveGameResultResponse> {
    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<SaveChargeResponse> {
    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<LoadGhostBattleInfoResponse> {
    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<LoadStampTargetResponse> {
    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<LockStampTargetResponse> {
    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<LoadGhostCompetitionInfoResponse> {
    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<LoadTimeAttackRecordResponse> {
    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<SaveTerminalResultResponse> {
    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<PingResponse> {
    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<LoadTerminalInformationResponse> {
    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<CreateUserResponse> {
    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<AskAccessCodeResponse> {
    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<RegisterOpponentGhostResponse> {
    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<LoadBookmarksResponse> {
    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<SaveBookmarksResponse> {
    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<GrantCarRightResponse> {
    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<LoadGhostCompetitionRankingResponse> {
    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<LoadUnreceivedUserItemsResponse> {
    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<StartTransferResponse> {
    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<SaveScreenshotResponse> {
    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<LoadScratchInformationResponse> {
    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<SaveScratchSheetResponse> {
    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<TurnScratchSheetResponse> {
    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<CheckItemReceivableCarsResponse> {
    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<ReceiveUserItemsResponse> {
    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<UpdateEventModeSerialResponse> {
    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<ConsumeUserItemResponse> {
    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<SearchCarsByLevelResponse> {
    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<LoadPathsAndTuningsResponse> {
    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<LoadGhostDriveDataResponse> {
    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<ParticipateInInviteFriendCampaignResponse> {
    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<LockCrownResponse> {
    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<SubmitClientLogResponse> {
    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<GhostTrail>;
  place_list(request: PlaceListQuery): Promise<PlaceList>;
  ghost_list(request: GhostListQuery): Promise<GhostList>;
  car_summary(request: CarSummaryQuery): Promise<CarSummary>;
  file_list(request: FileListQuery): Promise<FileList>;
  ghost_competition_target(
    request: GhostCompetitionTargetQuery
  ): Promise<GhostCompetitionTarget>;
  crown_list(request: CrownListQuery): Promise<CrownList>;
  ranking(request: RankingQuery): Promise<Ranking>;
}

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<GhostTrail> {
    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<PlaceList> {
    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<GhostList> {
    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<CarSummary> {
    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<FileList> {
    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<GhostCompetitionTarget> {
    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<CrownList> {
    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<Ranking> {
    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<Uint8Array>;
}

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> = T extends Builtin
  ? T
  : T extends Array<infer U>
  ? Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U>
  ? ReadonlyArray<DeepPartial<U>>
  : T extends {}
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin
  ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
        Exclude<keyof I, KeysOfUnion<P>>,
        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;
}