@goplus123/core-api 1.0.3 → 1.0.5

package/dist/index.js

@@ -7,46 +7,293 @@ var GrpcApiError = class extends Error {
   service;
   method;
   code;
+  baseUrl;
   constructor(options) {
     super(options.message ?? "gRPC request failed", { cause: options.cause });
     this.service = options.service;
     this.method = options.method;
     this.code = options.code;
+    this.baseUrl = options.baseUrl;
     this.cause = options.cause;
   }
 };
 var GrpcClient = class {
   transport;
+  baseUrl;
+  baseUrlByService;
+  resolveBaseUrl;
+  autoBaseUrlByNamespace;
+  protocol;
+  fetchImpl;
+  interceptors;
+  transportByBaseUrl;
   getToken;
   headers;
   getHeaders;
   logger;
+  invoker;
+  invokerClientByKey;
   constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.baseUrlByService = config.baseUrlByService;
+    this.resolveBaseUrl = config.resolveBaseUrl;
+    this.autoBaseUrlByNamespace = config.autoBaseUrlByNamespace ?? false;
+    this.fetchImpl = config.fetch;
     this.getToken = config.getToken;
     this.headers = config.headers;
     this.getHeaders = config.getHeaders;
+    this.invoker = config.invoker;
     this.logger = config.logger ?? (config.debug ? { debug: console.log, info: console.log, warn: console.warn, error: console.error } : void 0);
-    const interceptors = [this.createAuthInterceptor(), this.createLogInterceptor()];
+    this.interceptors = [
+      this.createRpcFromInterceptor(),
+      this.createAuthInterceptor(),
+      this.createLogInterceptor()
+    ];
+    this.protocol = (config.protocol ?? "grpc-web") === "connect" ? "connect" : "grpc-web";
+    this.transportByBaseUrl = /* @__PURE__ */ new Map();
+    this.transport = this.createTransport(this.baseUrl);
+    this.invokerClientByKey = /* @__PURE__ */ new Map();
+  }
+  createTransport(baseUrl) {
+    const cached = this.transportByBaseUrl.get(baseUrl);
+    if (cached) return cached;
     const transportOptions = {
-      baseUrl: config.baseUrl,
-      interceptors,
-      fetch: config.fetch
-      // 允许传入自定义 fetch
+      baseUrl,
+      interceptors: this.interceptors,
+      fetch: this.fetchImpl
     };
-    const protocol = config.protocol ?? "grpc-web";
-    this.transport = protocol === "grpc-web" ? createGrpcWebTransport(transportOptions) : createConnectTransport(transportOptions);
+    const t = this.protocol === "grpc-web" ? createGrpcWebTransport(transportOptions) : createConnectTransport(transportOptions);
+    this.transportByBaseUrl.set(baseUrl, t);
+    return t;
+  }
+  pickBaseUrl(serviceTypeName) {
+    const resolved = this.resolveBaseUrl?.(serviceTypeName);
+    if (resolved) return resolved;
+    const map = this.baseUrlByService ?? {};
+    const direct = map[serviceTypeName];
+    if (direct) return direct;
+    const ns = serviceTypeName.split(".")[0];
+    const byNs = map[ns];
+    if (byNs) return byNs;
+    if (this.autoBaseUrlByNamespace && ns) {
+      try {
+        const u = new URL(this.baseUrl);
+        u.pathname = `/${ns.toLowerCase()}`;
+        u.search = "";
+        u.hash = "";
+        return u.toString().replace(/\/$/, "");
+      } catch {
+        return this.baseUrl;
+      }
+    }
+    return this.baseUrl;
+  }
+  normalizeHeaders(input) {
+    if (!input) return {};
+    if (typeof Headers !== "undefined" && input instanceof Headers) {
+      const out = {};
+      input.forEach((value, key) => {
+        out[key] = value;
+      });
+      return out;
+    }
+    if (Array.isArray(input)) {
+      const out = {};
+      for (const pair of input) {
+        if (!pair) continue;
+        const [k, v] = pair;
+        if (k == null || v == null) continue;
+        out[String(k)] = String(v);
+      }
+      return out;
+    }
+    if (typeof input === "object") return { ...input };
+    return {};
+  }
+  hasHeader(headers, key) {
+    const lower = key.toLowerCase();
+    for (const k of Object.keys(headers)) {
+      if (k.toLowerCase() === lower) return true;
+    }
+    return false;
+  }
+  async attachInvokerHeaders(headers, methodName) {
+    const next = { ...headers };
+    if (methodName) {
+      const rpcFromKey = Object.keys(next).find((k) => k.toLowerCase() === "rpc_from");
+      const existing = rpcFromKey ? String(next[rpcFromKey] ?? "") : "";
+      if (!rpcFromKey || existing.trim().length === 0) {
+        next["rpc_from"] = methodName;
+      }
+    }
+    if (this.headers) {
+      for (const [key, value] of Object.entries(this.headers)) {
+        if (!this.hasHeader(next, key)) next[key] = value;
+      }
+    }
+    if (this.getHeaders) {
+      const extra = await this.getHeaders();
+      if (extra) {
+        for (const [key, value] of Object.entries(extra)) {
+          if (!this.hasHeader(next, key)) next[key] = value;
+        }
+      }
+    }
+    if (this.getToken && !this.hasHeader(next, "Authorization")) {
+      const token = await this.getToken();
+      if (token) next["Authorization"] = `Bearer ${token}`;
+    }
+    return next;
+  }
+  getInvokerClientKey(service, baseUrl) {
+    return `${String(service?.typeName ?? "")}@@${baseUrl}`;
+  }
+  getServiceMethodDesc(service, methodName) {
+    const methods = service?.methods;
+    if (!methods) return void 0;
+    if (Array.isArray(methods)) {
+      for (const m of methods) {
+        if (!m) continue;
+        const localName = String(m.localName ?? "");
+        const name = String(m.name ?? "");
+        if (localName === methodName || name === methodName) return m;
+      }
+      return void 0;
+    }
+    if (typeof methods === "object") {
+      return methods[methodName];
+    }
+    return void 0;
+  }
+  getServiceViaInvoker(service) {
+    const baseUrl = this.pickBaseUrl(service.typeName ?? "");
+    const key = this.getInvokerClientKey(service, baseUrl);
+    const cached = this.invokerClientByKey.get(key);
+    if (cached) return cached;
+    const methods = service?.methods;
+    const hasMethods = methods != null;
+    const methodMap = (() => {
+      if (!methods) return void 0;
+      if (Array.isArray(methods)) {
+        const out = {};
+        for (const m of methods) {
+          if (!m) continue;
+          const localName = String(m.localName ?? "");
+          const name = String(m.name ?? "");
+          if (localName) out[localName] = m;
+          if (name && !(name in out)) out[name] = m;
+        }
+        return out;
+      }
+      if (typeof methods === "object") return methods;
+      return void 0;
+    })();
+    const typeName = String(service?.typeName ?? "");
+    const client = new Proxy(
+      {},
+      {
+        get: (_target, prop) => {
+          if (prop === "then") return void 0;
+          if (typeof prop !== "string") return void 0;
+          if (hasMethods && methodMap && !(prop in methodMap)) {
+            return async () => {
+              throw new Error(`gRPC method not found: ${typeName}.${prop}`);
+            };
+          }
+          return async (request, options) => {
+            return await this.invokeUnary(service, prop, request, options);
+          };
+        }
+      }
+    );
+    this.invokerClientByKey.set(key, client);
+    return client;
+  }
+  async invokeUnary(service, methodName, request, options) {
+    const typeName = String(service?.typeName ?? "");
+    const baseUrl = this.pickBaseUrl(typeName);
+    try {
+      if (this.invoker) {
+        const method2 = this.getServiceMethodDesc(service, methodName);
+        const headers = await this.attachInvokerHeaders(
+          this.normalizeHeaders(options?.headers),
+          methodName
+        );
+        this.logger?.debug?.("[Grpc]", {
+          service: typeName,
+          methodName,
+          baseUrl,
+          messageType: request?.constructor?.name
+        });
+        const res = await this.invoker.unary({
+          baseUrl,
+          service,
+          methodName,
+          method: method2,
+          request,
+          headers,
+          callOptions: options
+        });
+        this.logger?.debug?.("[Grpc:Response]", {
+          service: typeName,
+          methodName,
+          baseUrl,
+          messageType: res?.constructor?.name
+        });
+        return res;
+      }
+      const transport = baseUrl === this.baseUrl ? this.transport : this.createTransport(baseUrl);
+      const client = createClient(service, transport);
+      const method = client?.[methodName];
+      if (typeof method !== "function") {
+        throw new Error(`gRPC method not found: ${typeName}.${methodName}`);
+      }
+      return await method(request, options);
+    } catch (err) {
+      this.logger?.error?.("[Grpc:Error]", { service: typeName, methodName, baseUrl, error: err });
+      if (err instanceof GrpcApiError) throw err;
+      throw new GrpcApiError({
+        service: typeName || baseUrl,
+        method: methodName,
+        code: err?.code,
+        baseUrl,
+        message: err?.message,
+        cause: err
+      });
+    }
   }
   /**
    * 创建特定服务的客户端实例
    * @param service Service Definition (从生成的 _connect.ts 导入)
    */
   getService(service) {
-    return createClient(service, this.transport);
+    if (this.invoker) {
+      return this.getServiceViaInvoker(service);
+    }
+    const baseUrl = this.pickBaseUrl(service.typeName ?? "");
+    const transport = baseUrl === this.baseUrl ? this.transport : this.createTransport(baseUrl);
+    return createClient(service, transport);
   }
   unary(schema, payload, call, options) {
     const req = create(schema, payload);
     return call(req, options);
   }
+  /**
+   * rpc_from 拦截器
+   */
+  createRpcFromInterceptor() {
+    return (next) => async (req) => {
+      const existing = req.header.get?.("rpc_from");
+      if (existing == null) {
+        const raw = req?.method?.name ?? req?.method?.localName ?? (typeof req?.url === "string" ? String(req.url).split("?")[0].split("/").pop() : void 0);
+        if (raw) {
+          const normalized = raw.length > 0 ? raw[0].toLowerCase() + raw.slice(1) : raw;
+          req.header.set("rpc_from", normalized);
+        }
+      }
+      return next(req);
+    };
+  }
   /**
    * 认证拦截器
    */
@@ -100,6 +347,13 @@ var GrpcClient = class {
           service: req.url,
           method: req.method,
           code: err?.code,
+          baseUrl: (() => {
+            try {
+              return new URL(req.url).origin;
+            } catch {
+              return void 0;
+            }
+          })(),
           message: err?.message,
           cause: err
         });
@@ -4547,12 +4801,1166 @@ var authEndpoints = {
   })
 };
 
+// src/spec/packet.ts
+var packetEndpoints = {
+  assignPacket: defineEndpoint({
+    id: "packet.assignPacket",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPacketService,
+      methodName: "assignPacket",
+      requestSchema: AssignPacketReqSchema
+    }
+  }),
+  getServerTime: defineEndpoint({
+    id: "packet.getServerTime",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPacketService,
+      methodName: "getServerTime",
+      requestSchema: GetServerTimeReqSchema
+    }
+  }),
+  getPacketsInfo: defineEndpoint({
+    id: "packet.getPacketsInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPacketService,
+      methodName: "getPacketsInfo",
+      requestSchema: GetPacketsInfoReqSchema
+    }
+  }),
+  verifyPlayerPacket: defineEndpoint({
+    id: "packet.verifyPlayerPacket",
+    transport: "grpc",
+    grpc: {
+      service: RecaptchaPacketService,
+      methodName: "verifyPlayerPacket",
+      requestSchema: VerifyPlayerPacketReqSchema
+    }
+  })
+};
+
+// src/spec/payment.ts
+var paymentEndpoints = {
+  getCredit: defineEndpoint({
+    id: "payment.getCredit",
+    transport: "grpc",
+    grpc: {
+      service: FrontendCreditService,
+      methodName: "getCredit",
+      requestSchema: GetCreditReqSchema
+    }
+  }),
+  getBankTypes: defineEndpoint({
+    id: "payment.getBankTypes",
+    transport: "grpc",
+    grpc: {
+      service: FrontendBankCardService,
+      methodName: "getBankTypes",
+      requestSchema: GetBankTypesReqSchema
+    }
+  }),
+  getBindBankCards: defineEndpoint({
+    id: "payment.getBindBankCards",
+    transport: "grpc",
+    grpc: {
+      service: FrontendBankCardService,
+      methodName: "getBindBankCards",
+      requestSchema: GetBindBankCardsReqSchema
+    }
+  }),
+  getAvailableDepositMethods: defineEndpoint({
+    id: "payment.getAvailableDepositMethods",
+    transport: "grpc",
+    grpc: {
+      service: FrontendBankCardService,
+      methodName: "getAvailableDepositMethods",
+      requestSchema: GetAvailableDepositMethodsReqSchema
+    }
+  }),
+  updatePaymentInfo: defineEndpoint({
+    id: "payment.updatePaymentInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendBankCardService,
+      methodName: "updatePaymentInfo",
+      requestSchema: UpdatePaymentInfoReqSchema
+    }
+  }),
+  verifyUnionBank: defineEndpoint(
+    {
+      id: "payment.verifyUnionBank",
+      transport: "grpc",
+      grpc: {
+        service: FrontendBankCardService,
+        methodName: "verifyUnionBank",
+        requestSchema: VerifyUnionBankReqSchema
+      }
+    }
+  ),
+  getPlayerDisbursements: defineEndpoint({
+    id: "payment.getPlayerDisbursements",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMudService,
+      methodName: "getPlayerDisbursements",
+      requestSchema: GetPlayerDisbursementsReqSchema
+    }
+  }),
+  claimPlayerDisbursement: defineEndpoint({
+    id: "payment.claimPlayerDisbursement",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMudService,
+      methodName: "claimPlayerDisbursement",
+      requestSchema: ClaimPlayerDisbursementReqSchema
+    }
+  }),
+  getPlayerMudTransactions: defineEndpoint({
+    id: "payment.getPlayerMudTransactions",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMudService,
+      methodName: "getPlayerMudTransactions",
+      requestSchema: GetPlayerMudTransactionsReqSchema
+    }
+  }),
+  getMudTransactionHistory: defineEndpoint({
+    id: "payment.getMudTransactionHistory",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMudService,
+      methodName: "getMudTransactionHistory",
+      requestSchema: GetMudTransactionHistoryReqSchema
+    }
+  }),
+  getCreditChangeNotifyMsg: defineEndpoint({
+    id: "payment.getCreditChangeNotifyMsg",
+    transport: "grpc",
+    grpc: {
+      service: FrontendDepositEffectService,
+      methodName: "getCreditChangeNotifyMsg",
+      requestSchema: EmptySchema
+    }
+  }),
+  removeCreditChangeNotifyMsg: defineEndpoint({
+    id: "payment.removeCreditChangeNotifyMsg",
+    transport: "grpc",
+    grpc: {
+      service: FrontendDepositEffectService,
+      methodName: "removeCreditChangeNotifyMsg",
+      requestSchema: RemoveCreditChangeNotifyMsgReqSchema
+    }
+  }),
+  getPlatformPlayerFreeSpinListing: defineEndpoint({
+    id: "payment.getPlatformPlayerFreeSpinListing",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFreeSpinService,
+      methodName: "getPlatformPlayerFreeSpinListing",
+      requestSchema: GetPlatformPlayerFreeSpinListingReqSchema
+    }
+  })
+};
+
+// src/spec/player.ts
+var playerEndpoints = {
+  getVerificationStatus: defineEndpoint({
+    id: "player.getVerificationStatus",
+    transport: "grpc",
+    grpc: {
+      service: FrontendEmailService,
+      methodName: "getVerificationStatus",
+      requestSchema: EmptySchema
+    }
+  }),
+  verifyEmail: defineEndpoint({
+    id: "player.verifyEmail",
+    transport: "grpc",
+    grpc: {
+      service: FrontendEmailService,
+      methodName: "verifyEmail",
+      requestSchema: VerifyEmailReqSchema
+    }
+  }),
+  getMergingList: defineEndpoint({
+    id: "player.getMergingList",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMergePlayerService,
+      methodName: "getMergingList",
+      requestSchema: EmptySchema
+    }
+  }),
+  mergePlayerAccount: defineEndpoint({
+    id: "player.mergePlayerAccount",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMergePlayerService,
+      methodName: "mergePlayer",
+      requestSchema: MergePlayerReqSchema
+    }
+  }),
+  verifyMergePlayerCode: defineEndpoint({
+    id: "player.verifyMergePlayerCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMergePlayerService,
+      methodName: "verifyMergePlayerCode",
+      requestSchema: VerifyMergePlayerCodeReqSchema
+    }
+  }),
+  getMergingListPendingProposalCount: defineEndpoint({
+    id: "player.getMergingListPendingProposalCount",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMergePlayerService,
+      methodName: "getMergingListPendingProposalCount",
+      requestSchema: EmptySchema
+    }
+  }),
+  checkMergePlayerProposal: defineEndpoint({
+    id: "player.checkMergePlayerProposal",
+    transport: "grpc",
+    grpc: {
+      service: FrontendMergePlayerService,
+      methodName: "checkMergePlayerProposal",
+      requestSchema: CheckMergePlayerProposalReqSchema
+    }
+  }),
+  playerBypassKycRestriction: defineEndpoint({
+    id: "player.playerBypassKycRestriction",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerPermissionService,
+      methodName: "playerBypassKycRestriction",
+      requestSchema: EmptySchema
+    }
+  }),
+  checkPlayerLoginStatus: defineEndpoint({
+    id: "player.checkPlayerLoginStatus",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "checkPlayerLoginStatus",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerProfileByJwt: defineEndpoint({
+    id: "player.getPlayerProfileByJwt",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "getPlayerProfileByJwt",
+      requestSchema: EmptySchema
+    }
+  }),
+  updatePassword: defineEndpoint({
+    id: "player.updatePassword",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "updatePassword",
+      requestSchema: UpdatePasswordReqSchema
+    }
+  }),
+  getPlayerInfoForSportsForum: defineEndpoint({
+    id: "player.getPlayerInfoForSportsForum",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "getPlayerInfoForSportsForum",
+      requestSchema: EmptySchema
+    }
+  }),
+  getWithdrawalInfo: defineEndpoint({
+    id: "player.getWithdrawalInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "getWithdrawalInfo",
+      requestSchema: EmptySchema
+    }
+  }),
+  getDepositInfo: defineEndpoint({
+    id: "player.getDepositInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "getDepositInfo",
+      requestSchema: EmptySchema
+    }
+  }),
+  getAccountCombineInfo: defineEndpoint({
+    id: "player.getAccountCombineInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "getAccountCombineInfo",
+      requestSchema: EmptySchema
+    }
+  }),
+  getViberStatus: defineEndpoint({
+    id: "player.getViberStatus",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "getViberStatus",
+      requestSchema: GetViberStatusReqSchema
+    }
+  }),
+  updateAdditionalInfo: defineEndpoint({
+    id: "player.updateAdditionalInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService2,
+      methodName: "updateAdditionalInfo",
+      requestSchema: UpdateAdditionalInfoReqSchema
+    }
+  }),
+  playerGetPlayerProfileByJwt: defineEndpoint({
+    id: "player.playerGetPlayerProfileByJwt",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerProfileByJwt",
+      requestSchema: EmptySchema
+    }
+  }),
+  playerUpdatePassword: defineEndpoint({
+    id: "player.playerUpdatePassword",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updatePassword",
+      requestSchema: UpdatePasswordReqSchema
+    }
+  }),
+  playerGetPlayerInfoForSportsForum: defineEndpoint({
+    id: "player.playerGetPlayerInfoForSportsForum",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerInfoForSportsForum",
+      requestSchema: EmptySchema
+    }
+  }),
+  playerGetWithdrawalInfo: defineEndpoint({
+    id: "player.playerGetWithdrawalInfo",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getWithdrawalInfo", requestSchema: EmptySchema }
+  }),
+  playerGetDepositInfo: defineEndpoint({
+    id: "player.playerGetDepositInfo",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getDepositInfo", requestSchema: EmptySchema }
+  }),
+  playerGetAccountCombineInfo: defineEndpoint({
+    id: "player.playerGetAccountCombineInfo",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getAccountCombineInfo",
+      requestSchema: EmptySchema
+    }
+  }),
+  playerGetViberStatus: defineEndpoint({
+    id: "player.playerGetViberStatus",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getViberStatus",
+      requestSchema: GetViberStatusReqSchema
+    }
+  }),
+  updatePasswordAndNotify: defineEndpoint({
+    id: "player.updatePasswordAndNotify",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updatePasswordAndNotify",
+      requestSchema: UpdatePasswordAndNotifyReqSchema
+    }
+  }),
+  resetPasswordFg: defineEndpoint({
+    id: "player.resetPasswordFg",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "resetPasswordFg",
+      requestSchema: ResetPasswordFgReqSchema
+    }
+  }),
+  updateDob: defineEndpoint({
+    id: "player.updateDob",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "updateDob", requestSchema: UpdateDobReqSchema }
+  }),
+  updatePlaceOfBirth: defineEndpoint(
+    {
+      id: "player.updatePlaceOfBirth",
+      transport: "grpc",
+      grpc: {
+        service: PlayerService,
+        methodName: "updatePlaceOfBirth",
+        requestSchema: UpdatePlaceOfBirthReqSchema
+      }
+    }
+  ),
+  updateGender: defineEndpoint({
+    id: "player.updateGender",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateGender",
+      requestSchema: UpdateGenderReqSchema
+    }
+  }),
+  updateNickname: defineEndpoint({
+    id: "player.updateNickname",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateNickname",
+      requestSchema: UpdateNicknameReqSchema
+    }
+  }),
+  updateEmail: defineEndpoint({
+    id: "player.updateEmail",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateEmail",
+      requestSchema: UpdateEmailReqSchema
+    }
+  }),
+  updateAddress: defineEndpoint({
+    id: "player.updateAddress",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateAddress",
+      requestSchema: UpdateAddressReqSchema
+    }
+  }),
+  updatePhone: defineEndpoint({
+    id: "player.updatePhone",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updatePhone",
+      requestSchema: UpdatePhoneReqSchema
+    }
+  }),
+  updatePlayerAvatar: defineEndpoint(
+    {
+      id: "player.updatePlayerAvatar",
+      transport: "grpc",
+      grpc: {
+        service: PlayerService,
+        methodName: "updatePlayerAvatar",
+        requestSchema: UpdatePlayerAvatarReqSchema
+      }
+    }
+  ),
+  updateEKyc: defineEndpoint({
+    id: "player.updateEKyc",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "updateEKyc", requestSchema: UpdateEKycReqSchema }
+  }),
+  getSmsStatus: defineEndpoint({
+    id: "player.getSmsStatus",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getSmsStatus", requestSchema: EmptySchema }
+  }),
+  updateSmsStatus: defineEndpoint({
+    id: "player.updateSmsStatus",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateSmsStatus",
+      requestSchema: UpdateSmsStatusReqSchema
+    }
+  }),
+  getAllLevel: defineEndpoint({
+    id: "player.getAllLevel",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getAllLevel", requestSchema: EmptySchema }
+  }),
+  getPlayerProgress: defineEndpoint({
+    id: "player.getPlayerProgress",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getPlayerProgress", requestSchema: EmptySchema }
+  }),
+  verifyPhoneNumberWithSms: defineEndpoint({
+    id: "player.verifyPhoneNumberWithSms",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "verifyPhoneNumberWithSms",
+      requestSchema: VerifyPhoneNumberWithSmsReqSchema
+    }
+  }),
+  updateSourceOfFunds: defineEndpoint({
+    id: "player.updateSourceOfFunds",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateSourceOfFunds",
+      requestSchema: UpdateSourceOfFundsReqSchema
+    }
+  }),
+  updateNatureOfWork: defineEndpoint(
+    {
+      id: "player.updateNatureOfWork",
+      transport: "grpc",
+      grpc: {
+        service: PlayerService,
+        methodName: "updateNatureOfWork",
+        requestSchema: UpdateNatureOfWorkReqSchema
+      }
+    }
+  ),
+  updateRealName: defineEndpoint({
+    id: "player.updateRealName",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateRealName",
+      requestSchema: UpdateRealNameReqSchema
+    }
+  }),
+  checkIsValidSmsCode: defineEndpoint({
+    id: "player.checkIsValidSmsCode",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "checkIsValidSmsCode",
+      requestSchema: CheckIsValidSmsCodeReqSchema
+    }
+  }),
+  getAllPlayerLevel: defineEndpoint({
+    id: "player.getAllPlayerLevel",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getAllPlayerLevel",
+      requestSchema: GetAllPlayerLevelReqSchema
+    }
+  }),
+  getPlayerLevelWithPlayerLevelObjId: defineEndpoint({
+    id: "player.getPlayerLevelWithPlayerLevelObjId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerLevelWithPlayerLevelObjId",
+      requestSchema: GetPlayerLevelWithPlayerLevelObjIdReqSchema
+    }
+  }),
+  getCasinoPlayerByPlayerId: defineEndpoint({
+    id: "player.getCasinoPlayerByPlayerId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getCasinoPlayerByPlayerId",
+      requestSchema: GetCasinoPlayerByPlayerIdReqSchema
+    }
+  }),
+  getCasinoPlayers: defineEndpoint({
+    id: "player.getCasinoPlayers",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getCasinoPlayers",
+      requestSchema: GetCasinoPlayersReqSchema
+    }
+  }),
+  getCasinoPlayerByMemberCardId: defineEndpoint({
+    id: "player.getCasinoPlayerByMemberCardId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getCasinoPlayerByMemberCardId",
+      requestSchema: GetCasinoPlayerByMemberCardIdReqSchema
+    }
+  }),
+  updateCasinoPlayerByPlayerId: defineEndpoint({
+    id: "player.updateCasinoPlayerByPlayerId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateCasinoPlayerByPlayerId",
+      requestSchema: UpdateCasinoPlayerByPlayerIdReqSchema
+    }
+  }),
+  updatePlayerStatusByPlayerId: defineEndpoint({
+    id: "player.updatePlayerStatusByPlayerId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updatePlayerStatusByPlayerId",
+      requestSchema: UpdatePlayerStatusByPlayerIdReqSchema
+    }
+  }),
+  getBetRecordsByPlayerId: defineEndpoint({
+    id: "player.getBetRecordsByPlayerId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getBetRecordsByPlayerId",
+      requestSchema: GetBetRecordsByPlayerIdReqSchema
+    }
+  }),
+  getPlayerInfoWithPlayerId: defineEndpoint({
+    id: "player.getPlayerInfoWithPlayerId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerInfoWithPlayerId",
+      requestSchema: GetPlayerInfoWithPlayerIdReqSchema
+    }
+  }),
+  updatePlayerBaccaratTicket: defineEndpoint({
+    id: "player.updatePlayerBaccaratTicket",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updatePlayerBaccaratTicket",
+      requestSchema: UpdatePlayerBaccaratTicketReqSchema
+    }
+  }),
+  getPlayerPhoneAndBankInfo: defineEndpoint({
+    id: "player.getPlayerPhoneAndBankInfo",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerPhoneAndBankInfo",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerKYCAndWithdrawStatus: defineEndpoint({
+    id: "player.getPlayerKYCAndWithdrawStatus",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerKYCAndWithdrawStatus",
+      requestSchema: GetPlayerKYCAndWithdrawStatusReqSchema
+    }
+  }),
+  getPlayerValidCreditByPlayerObjId: defineEndpoint({
+    id: "player.getPlayerValidCreditByPlayerObjId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerValidCreditByPlayerObjId",
+      requestSchema: GetPlayerValidCreditByPlayerObjIdReqSchema
+    }
+  }),
+  getPlayerIdAndName: defineEndpoint({
+    id: "player.getPlayerIdAndName",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getPlayerIdAndName", requestSchema: EmptySchema }
+  }),
+  getFreeSpinPlayerInfo: defineEndpoint({
+    id: "player.getFreeSpinPlayerInfo",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getFreeSpinPlayerInfo",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerInfo: defineEndpoint({
+    id: "player.getPlayerInfo",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerInfo",
+      requestSchema: GetPlayerInfoReqSchema
+    }
+  }),
+  getPlayerEmailByPlayerId: defineEndpoint({
+    id: "player.getPlayerEmailByPlayerId",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerEmailByPlayerId",
+      requestSchema: GetPlayerEmailByPlayerIdReqSchema
+    }
+  }),
+  getPlayerIdAndLevelByPhone: defineEndpoint({
+    id: "player.getPlayerIdAndLevelByPhone",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "getPlayerIdAndLevelByPhone",
+      requestSchema: GetPlayerIdAndLevelByPhoneReqSchema
+    }
+  }),
+  updateViberStatus: defineEndpoint({
+    id: "player.updateViberStatus",
+    transport: "grpc",
+    grpc: {
+      service: PlayerService,
+      methodName: "updateViberStatus",
+      requestSchema: UpdateViberStatusReqSchema
+    }
+  }),
+  getPlayerAvatars: defineEndpoint({
+    id: "player.getPlayerAvatars",
+    transport: "grpc",
+    grpc: { service: PlayerService, methodName: "getPlayerAvatars", requestSchema: EmptySchema }
+  }),
+  getKycParamsConfig: defineEndpoint({
+    id: "player.getKycParamsConfig",
+    transport: "grpc",
+    grpc: {
+      service: FrontendZolozService,
+      methodName: "getKycParamsConfig",
+      requestSchema: GetKycParamsConfigReqSchema
+    }
+  }),
+  ekycInit: defineEndpoint({
+    id: "player.ekycInit",
+    transport: "grpc",
+    grpc: {
+      service: FrontendZolozService,
+      methodName: "ekycInit",
+      requestSchema: EkycInitReqSchema
+    }
+  }),
+  ekycResult: defineEndpoint({
+    id: "player.ekycResult",
+    transport: "grpc",
+    grpc: {
+      service: FrontendZolozService,
+      methodName: "ekycResult",
+      requestSchema: EkycResultReqSchema
+    }
+  })
+};
+
+// src/spec/promotion.ts
+var promotionEndpoints = {
+  getTodayLiveDrawEvents: defineEndpoint({
+    id: "promotion.getTodayLiveDrawEvents",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "getTodayLiveDrawEvents",
+      requestSchema: GetTodayLiveDrawEventsReqSchema
+    }
+  }),
+  getTodayCurrentRoundLiveDrawEvents: defineEndpoint({
+    id: "promotion.getTodayCurrentRoundLiveDrawEvents",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "getTodayCurrentRoundLiveDrawEvents",
+      requestSchema: GetTodayCurrentRoundLiveDrawEventsReqSchema
+    }
+  }),
+  startLiveDrawEvent: defineEndpoint({
+    id: "promotion.startLiveDrawEvent",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "startLiveDrawEvent",
+      requestSchema: StartLiveDrawEventReqSchema
+    }
+  }),
+  redrawLiveDrawEvent: defineEndpoint({
+    id: "promotion.redrawLiveDrawEvent",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "redrawLiveDrawEvent",
+      requestSchema: RedrawLiveDrawEventReqSchema
+    }
+  }),
+  confirmLiveDraw: defineEndpoint(
+    {
+      id: "promotion.confirmLiveDraw",
+      transport: "grpc",
+      grpc: {
+        service: AdminLiveDrawService,
+        methodName: "confirmLiveDraw",
+        requestSchema: ConfirmLiveDrawReqSchema
+      }
+    }
+  ),
+  liveDrawEventPhoneCallPlayer: defineEndpoint({
+    id: "promotion.liveDrawEventPhoneCallPlayer",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "liveDrawEventPhoneCallPlayer",
+      requestSchema: LiveDrawEventPhoneCallPlayerReqSchema
+    }
+  }),
+  getLiveDrawEventWinnerList: defineEndpoint({
+    id: "promotion.getLiveDrawEventWinnerList",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "getLiveDrawEventWinnerList",
+      requestSchema: GetLiveDrawEventWinnerListReqSchema
+    }
+  }),
+  makePhoneCall: defineEndpoint({
+    id: "promotion.makePhoneCall",
+    transport: "grpc",
+    grpc: {
+      service: AdminLiveDrawService,
+      methodName: "makePhoneCall",
+      requestSchema: MakePhoneCallReqSchema
+    }
+  }),
+  getCharityDetail: defineEndpoint({
+    id: "promotion.getCharityDetail",
+    transport: "grpc",
+    grpc: {
+      service: FrontendCharityService,
+      methodName: "getCharityDetail",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerCharityDetail: defineEndpoint({
+    id: "promotion.getPlayerCharityDetail",
+    transport: "grpc",
+    grpc: {
+      service: FrontendCharityService,
+      methodName: "getPlayerCharityDetail",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerRewardProgress: defineEndpoint({
+    id: "promotion.getPlayerRewardProgress",
+    transport: "grpc",
+    grpc: {
+      service: FrontendLeaderboardService,
+      methodName: "getPlayerRewardProgress",
+      requestSchema: GetPlayerRewardProgressReqSchema
+    }
+  }),
+  claimReward: defineEndpoint({
+    id: "promotion.claimReward",
+    transport: "grpc",
+    grpc: {
+      service: FrontendLeaderboardService,
+      methodName: "claimReward",
+      requestSchema: ClaimRewardReqSchema
+    }
+  }),
+  getLuckyDrawRewardList: defineEndpoint({
+    id: "promotion.getLuckyDrawRewardList",
+    transport: "grpc",
+    grpc: {
+      service: FrontendLiveDrawService,
+      methodName: "getLuckyDrawRewardList",
+      requestSchema: GetLuckyDrawRewardListReqSchema
+    }
+  }),
+  getPlayerTicketList: defineEndpoint({
+    id: "promotion.getPlayerTicketList",
+    transport: "grpc",
+    grpc: {
+      service: FrontendLiveDrawService,
+      methodName: "getPlayerTicketList",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerInRiskList: defineEndpoint({
+    id: "promotion.getPlayerInRiskList",
+    transport: "grpc",
+    grpc: {
+      service: FrontendLiveDrawService,
+      methodName: "getPlayerInRiskList",
+      requestSchema: EmptySchema
+    }
+  }),
+  claimCampaignPromoCode: defineEndpoint({
+    id: "promotion.claimCampaignPromoCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPromotionService,
+      methodName: "claimCampaignPromoCode",
+      requestSchema: ClaimCampaignPromoCodeReqSchema
+    }
+  }),
+  hasReceiveEventCampaignReward: defineEndpoint({
+    id: "promotion.hasReceiveEventCampaignReward",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPromotionService,
+      methodName: "hasReceiveEventCampaignReward",
+      requestSchema: HasReceiveEventCampaignRewardReqSchema
+    }
+  }),
+  getPlayerFreeSpinInfo: defineEndpoint({
+    id: "promotion.getPlayerFreeSpinInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendService,
+      methodName: "getPlayerFreeSpinInfo",
+      requestSchema: GetPlayerFreeSpinInfoReqSchema
+    }
+  }),
+  getFreeSpinHistory: defineEndpoint({
+    id: "promotion.getFreeSpinHistory",
+    transport: "grpc",
+    grpc: {
+      service: FrontendService,
+      methodName: "getFreeSpinHistory",
+      requestSchema: GetFreeSpinHistoryReqSchema
+    }
+  }),
+  getCurrentMissionConfig: defineEndpoint({
+    id: "promotion.getCurrentMissionConfig",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getCurrentMissionConfig",
+      requestSchema: EmptySchema
+    }
+  }),
+  getPlayerTaskProgress: defineEndpoint({
+    id: "promotion.getPlayerTaskProgress",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getPlayerTaskProgress",
+      requestSchema: GetPlayerTaskProgressReqSchema
+    }
+  }),
+  claimTaskReward: defineEndpoint(
+    {
+      id: "promotion.claimTaskReward",
+      transport: "grpc",
+      grpc: {
+        service: FrontendSpecialEventService,
+        methodName: "claimTaskReward",
+        requestSchema: ClaimTaskRewardReqSchema
+      }
+    }
+  ),
+  checkAndCreateMission: defineEndpoint({
+    id: "promotion.checkAndCreateMission",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "checkAndCreateMission",
+      requestSchema: CheckAndCreateMissionReqSchema
+    }
+  }),
+  getCurrentCardEvents: defineEndpoint({
+    id: "promotion.getCurrentCardEvents",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getCurrentCardEvents",
+      requestSchema: EmptySchema
+    }
+  }),
+  playerReceiveEgg: defineEndpoint({
+    id: "promotion.playerReceiveEgg",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "playerReceiveEgg",
+      requestSchema: PlayerReceiveEggReqSchema
+    }
+  }),
+  getConsumptionProgress: defineEndpoint({
+    id: "promotion.getConsumptionProgress",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getConsumptionProgress",
+      requestSchema: GetConsumptionProgressReqSchema
+    }
+  }),
+  playerClaimAllDailyReward: defineEndpoint({
+    id: "promotion.playerClaimAllDailyReward",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "playerClaimAllDailyReward",
+      requestSchema: PlayerClaimAllDailyRewardReqSchema
+    }
+  }),
+  claimTimedEventReward: defineEndpoint({
+    id: "promotion.claimTimedEventReward",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "claimTimedEventReward",
+      requestSchema: ClaimTimedEventRewardReqSchema
+    }
+  }),
+  getEventRewardHistory: defineEndpoint({
+    id: "promotion.getEventRewardHistory",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getEventRewardHistory",
+      requestSchema: GetEventRewardHistoryReqSchema
+    }
+  }),
+  dailyClaimReward: defineEndpoint({
+    id: "promotion.dailyClaimReward",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "dailyClaimReward",
+      requestSchema: DailyClaimRewardReqSchema
+    }
+  }),
+  queryPlayerEgg: defineEndpoint({
+    id: "promotion.queryPlayerEgg",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "queryPlayerEgg",
+      requestSchema: QueryPlayerEggReqSchema
+    }
+  }),
+  updateTutorialFlag: defineEndpoint({
+    id: "promotion.updateTutorialFlag",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "updateTutorialFlag",
+      requestSchema: UpdateTutorialFlagReqSchema
+    }
+  }),
+  referralAssistance: defineEndpoint({
+    id: "promotion.referralAssistance",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "referralAssistance",
+      requestSchema: ReferralAssistanceReqSchema
+    }
+  }),
+  getSingleRewardInfo: defineEndpoint({
+    id: "promotion.getSingleRewardInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getSingleRewardInfo",
+      requestSchema: GetSingleRewardInfoReqSchema
+    }
+  }),
+  getPlayerRedPacketRecords: defineEndpoint({
+    id: "promotion.getPlayerRedPacketRecords",
+    transport: "grpc",
+    grpc: {
+      service: FrontendSpecialEventService,
+      methodName: "getPlayerRedPacketRecords",
+      requestSchema: GetPlayerRedPacketRecordsReqSchema
+    }
+  })
+};
+
+// src/spec/recommend.ts
+var recommendEndpoints = {
+  saveSearchHistory: defineEndpoint({
+    id: "recommend.saveSearchHistory",
+    transport: "grpc",
+    grpc: {
+      service: FrontendRecommendService,
+      methodName: "saveSearchHistory",
+      requestSchema: SaveSearchHistoryReqSchema
+    }
+  }),
+  getSearchHistories: defineEndpoint({
+    id: "recommend.getSearchHistories",
+    transport: "grpc",
+    grpc: {
+      service: FrontendRecommendService,
+      methodName: "getSearchHistories",
+      requestSchema: EmptySchema
+    }
+  }),
+  deleteSearchHistory: defineEndpoint({
+    id: "recommend.deleteSearchHistory",
+    transport: "grpc",
+    grpc: {
+      service: FrontendRecommendService,
+      methodName: "deleteSearchHistory",
+      requestSchema: DeleteSearchHistoryReqSchema
+    }
+  }),
+  searchGames: defineEndpoint({
+    id: "recommend.searchGames",
+    transport: "grpc",
+    grpc: {
+      service: FrontendRecommendService,
+      methodName: "searchGames",
+      requestSchema: SearchGamesReqSchema
+    }
+  })
+};
+
+// src/spec/riskcontrol.ts
+var riskcontrolEndpoints = {
+  getPlayerDepositLimitStateOverview: defineEndpoint({
+    id: "riskcontrol.getPlayerDepositLimitStateOverview",
+    transport: "grpc",
+    grpc: {
+      service: FrontendDepositLimitService,
+      methodName: "getPlayerDepositLimitStateOverview",
+      requestSchema: EmptySchema
+    }
+  }),
+  updatePlayerDepositLimitSwitch: defineEndpoint({
+    id: "riskcontrol.updatePlayerDepositLimitSwitch",
+    transport: "grpc",
+    grpc: {
+      service: FrontendDepositLimitService,
+      methodName: "updatePlayerDepositLimitSwitch",
+      requestSchema: UpdatePlayerDepositLimitSwitchReqSchema
+    }
+  }),
+  updatePlayerPeriodDepositLimit: defineEndpoint({
+    id: "riskcontrol.updatePlayerPeriodDepositLimit",
+    transport: "grpc",
+    grpc: {
+      service: FrontendDepositLimitService,
+      methodName: "updatePlayerPeriodDepositLimit",
+      requestSchema: UpdatePlayerPeriodDepositLimitReqSchema
+    }
+  })
+};
+
+// src/spec/userEngagement.ts
+var userEngagementEndpoints = {
+  updatePWASubscriptionStatus: defineEndpoint({
+    id: "userEngagement.updatePWASubscriptionStatus",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPwaNotificationService,
+      methodName: "updatePWASubscriptionStatus",
+      requestSchema: UpdatePWASubscriptionStatusReqSchema
+    }
+  })
+};
+
 // src/spec/index.ts
 var apiMap = {
   platform: platformEndpoints,
   admin: adminEndpoints,
   cms: cmsEndpoints,
-  auth: authEndpoints
+  auth: authEndpoints,
+  packet: packetEndpoints,
+  payment: paymentEndpoints,
+  player: playerEndpoints,
+  promotion: promotionEndpoints,
+  recommend: recommendEndpoints,
+  riskcontrol: riskcontrolEndpoints,
+  userEngagement: userEngagementEndpoints
 };
 
 // src/routing/router.ts