@goplus123/core-api 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   apiError: () => apiError,
   callApi: () => requestApi,
+  createFetchGuid: () => createFetchGuid,
   destroySDK: () => destroySDK,
   fetchGuid: () => fetchGuid,
   getSDK: () => getSDK,
@@ -29,7 +30,9 @@ __export(index_exports, {
   initSDK: () => initSDK,
   notify: () => notify,
   requestApi: () => requestApi,
-  requestApiSpec: () => requestApi
+  requestApiSpec: () => requestApi,
+  setUniqueKeyStorage: () => setUniqueKeyStorage,
+  webStorage: () => webStorage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -42,46 +45,258 @@ 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" ? (0, import_connect_web.createGrpcWebTransport)(transportOptions) : (0, import_connect_web.createConnectTransport)(transportOptions);
+    const t = this.protocol === "grpc-web" ? (0, import_connect_web.createGrpcWebTransport)(transportOptions) : (0, import_connect_web.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}`;
+  }
+  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 hasMethodsMap = methods && typeof methods === "object";
+    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 (hasMethodsMap && !(prop in methods)) {
+            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 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,
+          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 = (0, import_connect.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 (0, import_connect.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 (0, import_connect.createClient)(service, transport);
   }
   unary(schema, payload, call, options) {
     const req = (0, import_protobuf.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);
+    };
+  }
   /**
    * 认证拦截器
    */
@@ -135,6 +350,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
         });
@@ -429,7 +651,7 @@ var WsClient = class {
         ...options.reconnect
       },
       heartbeat: {
-        interval: 1e4,
+        interval: 3e4,
         timeout: 3e4,
         pingType: "ping",
         pongType: "pong",
@@ -715,6 +937,10 @@ var WsClient = class {
           this.lastPongTime = Date.now();
           return;
         }
+        if (this.isAliveAck(msg, payload)) {
+          this.lastPongTime = Date.now();
+          return;
+        }
         const requestId = msg.requestId ?? (payload && typeof payload === "object" ? payload.requestId ?? payload?.data?.requestId : void 0);
         const resolved = requestId ? this.tryResolvePending(requestId, type, payload) : false;
         if (!resolved) {
@@ -730,6 +956,10 @@ var WsClient = class {
           this.lastPongTime = Date.now();
           return;
         }
+        if (this.isAliveAck(msg, payload)) {
+          this.lastPongTime = Date.now();
+          return;
+        }
         const requestId = msg.requestId ?? (payload && typeof payload === "object" ? payload.requestId ?? payload?.data?.requestId : void 0);
         const resolved = requestId ? this.tryResolvePending(requestId, functionName, payload) : false;
         if (!resolved) {
@@ -779,7 +1009,23 @@ var WsClient = class {
     const ping = () => {
       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
       this.lastPingTime = Date.now();
-      this.send(hb.pingType ?? "ping");
+      const requestId = this.requestId;
+      const deviceType = this.headerConfig.deviceType === "" || this.headerConfig.deviceType === void 0 ? 1 : this.headerConfig.deviceType;
+      const message = JSON.stringify({
+        service: "connection",
+        functionName: "isAlive",
+        data: {
+          _heartBeat: true,
+          deviceType,
+          deviceId: this.headerConfig.deviceId ?? "",
+          platformId: this.headerConfig.platformId ?? "",
+          version: this.headerConfig.version ?? "",
+          uuid: this.options.protocols,
+          requestId,
+          childPlatformId: this.headerConfig.childPlatformId ?? ""
+        }
+      });
+      this.ws.send(message);
     };
     ping();
     this.heartbeatTimer = window.setInterval(() => {
@@ -898,6 +1144,12 @@ var WsClient = class {
   isPong(type) {
     return type === (this.options.heartbeat?.pongType ?? "pong");
   }
+  isAliveAck(msg, payload) {
+    if (!msg || typeof msg !== "object") return false;
+    if (msg.service !== "connection") return false;
+    if (msg.functionName !== "isAlive" && msg.type !== "isAlive") return false;
+    return payload && typeof payload === "object" && payload.status === 200;
+  }
   async buildURL(params) {
     let urlStr = this.options.url;
     if (!/^\w+:\/\//.test(urlStr)) {
@@ -4278,231 +4530,1813 @@ var cmsEndpoints = {
   })
 };
 
-// src/spec/index.ts
-var apiMap = {
-  platform: platformEndpoints,
-  admin: adminEndpoints,
-  cms: cmsEndpoints
-};
-
-// src/routing/router.ts
-var serviceInstances = {};
-var rpcClient;
-var unifiedClient;
-var endpointRegistry = /* @__PURE__ */ new Map();
-var endpointDefaultTransports = /* @__PURE__ */ new Map();
-var defaultTransport = "auto";
-var transportState = {
-  hasHttp: false,
-  hasWs: false,
-  hasGrpc: false
-};
-function resetRoutingState() {
-  serviceInstances = {};
-  rpcClient = void 0;
-  unifiedClient = void 0;
-  endpointRegistry.clear();
-  endpointDefaultTransports.clear();
-  defaultTransport = "auto";
-  transportState = { hasHttp: false, hasWs: false, hasGrpc: false };
-}
-function setServiceInstances(instances) {
-  serviceInstances = instances;
-}
-function setRpcClient(client) {
-  rpcClient = client;
-}
-function setUnifiedClient(client) {
-  unifiedClient = client;
-}
-function setTransportState(state) {
-  transportState = state;
-}
-function setDefaultTransport(transport) {
-  defaultTransport = transport;
-}
-function makeEndpointKey(service, functionName) {
-  return `${service}:${functionName}`;
-}
-function isEndpointSpec(value) {
-  return !!value && typeof value === "object" && "transport" in value;
-}
-function isEndpointGroup(value) {
-  return !!value && typeof value === "object" && "transports" in value;
-}
-function registerEndpointVariant(service, functionName, endpoint) {
-  const key = makeEndpointKey(service, functionName);
-  let byTransport = endpointRegistry.get(key);
-  if (!byTransport) {
-    byTransport = /* @__PURE__ */ new Map();
-    endpointRegistry.set(key, byTransport);
-  }
-  byTransport.set(endpoint.transport, endpoint);
-}
-function rebuildEndpointRegistry() {
-  endpointRegistry = /* @__PURE__ */ new Map();
-  endpointDefaultTransports = /* @__PURE__ */ new Map();
-  for (const [serviceName, service] of Object.entries(apiMap)) {
-    for (const [functionName, endpoint] of Object.entries(service)) {
-      if (isEndpointSpec(endpoint)) {
-        registerEndpointVariant(serviceName, functionName, endpoint);
-        continue;
-      }
-      if (isEndpointGroup(endpoint)) {
-        if (endpoint.defaultTransport) {
-          endpointDefaultTransports.set(
-            makeEndpointKey(serviceName, functionName),
-            endpoint.defaultTransport
-          );
-        }
-        for (const [transport, config] of Object.entries(endpoint.transports ?? {})) {
-          if (!config) continue;
-          if (transport === "http") {
-            registerEndpointVariant(serviceName, functionName, {
-              id: endpoint.id,
-              transport: "http",
-              http: config,
-              request: endpoint.request,
-              response: endpoint.response
-            });
-          } else if (transport === "ws") {
-            registerEndpointVariant(serviceName, functionName, {
-              id: endpoint.id,
-              transport: "ws",
-              ws: config,
-              request: endpoint.request,
-              response: endpoint.response
-            });
-          } else if (transport === "grpc") {
-            registerEndpointVariant(serviceName, functionName, {
-              id: endpoint.id,
-              transport: "grpc",
-              grpc: config,
-              request: endpoint.request,
-              response: endpoint.response
-            });
-          }
-        }
-        continue;
-      }
+// src/spec/auth.ts
+var authEndpoints = {
+  playerRegisterRequestCode: defineEndpoint({
+    id: "auth.playerRegisterRequestCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerRegisterRequestCode",
+      requestSchema: PlayerRegisterRequestCodeReqSchema
     }
-  }
-}
-function requestApi(args) {
-  const key = makeEndpointKey(args.service, args.functionName);
-  const endpointVariants = endpointRegistry.get(key);
-  if (endpointVariants) {
-    if (!unifiedClient) {
-      throw new Error("SDK not initialized. Please call initSDK first.");
+  }),
+  playerRegisterWithCode: defineEndpoint({
+    id: "auth.playerRegisterWithCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerRegisterWithCode",
+      requestSchema: PlayerRegisterWithCodeReqSchema
     }
-    const specDefaultTransport = endpointDefaultTransports.get(key);
-    const endpoint = pickEndpoint(
-      endpointVariants,
-      args.transport,
-      specDefaultTransport,
-      args.service,
-      args.functionName
-    );
-    if (endpoint.transport === "grpc" && !transportState.hasGrpc) {
-      throw new Error("SDK not initialized. Please call initSDK with grpc config.");
+  }),
+  playerLoginWithSessionToken: defineEndpoint({
+    id: "auth.playerLoginWithSessionToken",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerLoginWithSessionToken",
+      requestSchema: PlayerLoginWithSessionTokenReqSchema
     }
-    if (endpoint.transport === "ws" && !transportState.hasWs) {
-      throw new Error("SDK not initialized. Please call initSDK with ws config.");
+  }),
+  phoneNumberLoginWithPassword: defineEndpoint({
+    id: "auth.phoneNumberLoginWithPassword",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "phoneNumberLoginWithPassword",
+      requestSchema: PhoneNumberLoginWithPasswordReqSchema
     }
-    if (endpoint.transport === "http" && !transportState.hasHttp) {
-      throw new Error("SDK not initialized. Please call initSDK with http config.");
+  }),
+  playerLoginOrRegisterWithSMS: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithSMS",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerLoginOrRegisterWithSMS",
+      requestSchema: PlayerLoginOrRegisterWithSMSReqSchema
     }
-    const meta = args.callOptions || args.wsOptions ? {
-      ...args.meta ?? {},
-      ...args.callOptions ? { callOptions: args.callOptions } : {},
-      ...args.wsOptions ? { wsOptions: args.wsOptions } : {}
-    } : args.meta;
-    return unifiedClient.call(endpoint, args.requestParam, meta);
-  }
-  const serviceInstance = serviceInstances[args.service];
-  const method = serviceInstance?.[args.functionName];
-  if (typeof method === "function") {
-    if (args.callOptions !== void 0) {
-      return method(args.requestParam, args.callOptions);
+  }),
+  playerLogout: defineEndpoint({
+    id: "auth.playerLogout",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerLogout",
+      requestSchema: PlayerLogoutReqSchema
     }
-    return method(args.requestParam);
-  }
-  if (!rpcClient) {
-    throw new Error("SDK not initialized. Please call initSDK first.");
-  }
-  return rpcClient.call(args.functionName, args.service, args.requestParam, args.wsOptions);
-}
-function pickEndpoint(variants, transport, specDefaultTransport, service, functionName) {
-  const resolvedTransport = transport ?? specDefaultTransport ?? defaultTransport;
-  if (resolvedTransport !== "auto") {
-    const found = variants.get(resolvedTransport);
-    if (!found) {
-      throw new Error(
-        `Endpoint transport not found: ${service}.${functionName} (${resolvedTransport}). Available: ${Array.from(
-          variants.keys()
-        ).join(", ")}`
-      );
+  }),
+  authenticate: defineEndpoint({
+    id: "auth.authenticate",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "authenticate",
+      requestSchema: AuthenticateReqSchema
     }
-    return found;
-  }
-  if (transportState.hasGrpc && variants.has("grpc")) return variants.get("grpc");
-  if (transportState.hasWs && variants.has("ws")) return variants.get("ws");
-  if (transportState.hasHttp && variants.has("http")) return variants.get("http");
-  const fallback = variants.values().next().value;
-  if (!fallback) {
-    throw new Error(`Endpoint not found: ${service}.${functionName}`);
-  }
-  return fallback;
-}
-
-// src/utils/uniqueKey.ts
-var fetchGuid = () => {
-  let guid = getLocalItem("uKey");
-  console.log("fetchGuid", JSON.stringify(guid));
-  if (!guid) {
-    guid = generateGuid();
-    setLocalItem("uKey", maskingGuid(true, guid));
-  } else {
-    guid = maskingGuid(false, null);
-  }
-  return guid;
-};
-var generateGuid = () => {
-  return "10000000-1000-4000-8000-100000000000".replace(
-    /[018]/g,
-    (c) => (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
-  );
+  }),
+  sendSmsCode: defineEndpoint({
+    id: "auth.sendSmsCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "sendSmsCode",
+      requestSchema: SendSmsCodeReqSchema
+    }
+  }),
+  sendSmsCodeViber: defineEndpoint({
+    id: "auth.sendSmsCodeViber",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "sendSmsCodeViber",
+      requestSchema: SendSmsCodeViberReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithFacebook: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithFacebook",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "playerLoginOrRegisterWithFacebook",
+      requestSchema: PlayerLoginOrRegisterWithFacebookReqSchema
+    }
+  }),
+  getFacebookConsentPage: defineEndpoint({
+    id: "auth.getFacebookConsentPage",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "getFacebookConsentPage",
+      requestSchema: GetFacebookConsentPageReqSchema
+    }
+  }),
+  facebookAuthorization: defineEndpoint({
+    id: "auth.facebookAuthorization",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "facebookAuthorization",
+      requestSchema: FacebookAuthorizationReqSchema
+    }
+  }),
+  getFacebookFriendList: defineEndpoint({
+    id: "auth.getFacebookFriendList",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "getFacebookFriendList",
+      requestSchema: GetFacebookFriendListReqSchema
+    }
+  }),
+  manualFetchFacebookFriends: defineEndpoint({
+    id: "auth.manualFetchFacebookFriends",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "manualFetchFacebookFriends",
+      requestSchema: ManualFetchFacebookFriendsReqSchema
+    }
+  }),
+  bindFacebookAccount: defineEndpoint({
+    id: "auth.bindFacebookAccount",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "bindFacebookAccount",
+      requestSchema: BindFacebookAccountReqSchema
+    }
+  }),
+  unbindFacebookAccount: defineEndpoint({
+    id: "auth.unbindFacebookAccount",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "unbindFacebookAccount",
+      requestSchema: EmptySchema
+    }
+  }),
+  facebookVerifyPhoneNumber: defineEndpoint({
+    id: "auth.facebookVerifyPhoneNumber",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "facebookVerifyPhoneNumber",
+      requestSchema: FacebookVerifyPhoneNumberReqSchema
+    }
+  }),
+  enableFaceId: defineEndpoint({
+    id: "auth.enableFaceId",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "enableFaceId",
+      requestSchema: EnableFaceIdReqSchema
+    }
+  }),
+  initFaceIdSession: defineEndpoint({
+    id: "auth.initFaceIdSession",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "initFaceIdSession",
+      requestSchema: InitFaceIdSessionReqSchema
+    }
+  }),
+  playerLoginWithFaceId: defineEndpoint({
+    id: "auth.playerLoginWithFaceId",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "playerLoginWithFaceId",
+      requestSchema: PlayerLoginWithFaceIdReqSchema
+    }
+  }),
+  disableFaceId: defineEndpoint({
+    id: "auth.disableFaceId",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "disableFaceId",
+      requestSchema: DisableFaceIdReqSchema
+    }
+  }),
+  initEnrollSession: defineEndpoint({
+    id: "auth.initEnrollSession",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "initEnrollSession",
+      requestSchema: InitEnrollSessionReqSchema
+    }
+  }),
+  getFaceIdInfo: defineEndpoint({
+    id: "auth.getFaceIdInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "getFaceIdInfo",
+      requestSchema: GetFaceIdInfoReqSchema
+    }
+  }),
+  verifyPassword: defineEndpoint({
+    id: "auth.verifyPassword",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService,
+      methodName: "verifyPassword",
+      requestSchema: VerifyPasswordReqSchema
+    }
+  }),
+  gLifeAuth: defineEndpoint({
+    id: "auth.gLifeAuth",
+    transport: "grpc",
+    grpc: {
+      service: GLifeService,
+      methodName: "gLifeAuth",
+      requestSchema: GLifeAuthReqSchema
+    }
+  }),
+  playerLoginWithGLife: defineEndpoint({
+    id: "auth.playerLoginWithGLife",
+    transport: "grpc",
+    grpc: {
+      service: GLifeService,
+      methodName: "playerLoginWithGLife",
+      requestSchema: PlayerLoginWithGLifeReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithGLife: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithGLife",
+    transport: "grpc",
+    grpc: {
+      service: GLifeService,
+      methodName: "playerLoginOrRegisterWithGLife",
+      requestSchema: PlayerLoginOrRegisterWithGLifeReqSchema
+    }
+  }),
+  mayaAuth: defineEndpoint({
+    id: "auth.mayaAuth",
+    transport: "grpc",
+    grpc: {
+      service: MayaService,
+      methodName: "mayaAuth",
+      requestSchema: MayaAuthReqSchema
+    }
+  }),
+  playerLoginWithMaya: defineEndpoint({
+    id: "auth.playerLoginWithMaya",
+    transport: "grpc",
+    grpc: {
+      service: MayaService,
+      methodName: "playerLoginWithMaya",
+      requestSchema: PlayerLoginWithMayaReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithMaya: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithMaya",
+    transport: "grpc",
+    grpc: {
+      service: MayaService,
+      methodName: "playerLoginOrRegisterWithMaya",
+      requestSchema: PlayerLoginOrRegisterWithMayaReqSchema
+    }
+  })
+};
+
+// 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
+    }
+  })
 };
-var maskingGuid = (isMask, oriUKey) => {
-  let _uKey2;
-  let uKey = oriUKey || getLocalItem("uKey");
-  if (isMask) {
-    let _uKey;
-    uKey = ((_uKey = uKey) == null ? void 0 : _uKey.replace(/-/g, "")) || "";
-    const _buffer = new Uint8Array(uKey.length / 2);
-    for (let i = 0; i < uKey.length; i += 2) {
-      _buffer[i / 2] = parseInt(uKey.substr(i, 2), 16);
-    }
-    return btoa(String.fromCharCode.apply(null, Array.from(_buffer)));
-  }
-  uKey = ((_uKey2 = uKey) == null ? void 0 : _uKey2.replace(/"/g, "")) || "";
-  const buffer = atob(uKey);
-  const hex = Array.prototype.map.call(
-    new Uint8Array(buffer.length).map((_, i) => buffer.charCodeAt(i)),
-    (byte) => ("0" + (byte & 255).toString(16)).slice(-2)
-  ).join("");
-  return hex.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+
+// 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,
+  packet: packetEndpoints,
+  payment: paymentEndpoints,
+  player: playerEndpoints,
+  promotion: promotionEndpoints,
+  recommend: recommendEndpoints,
+  riskcontrol: riskcontrolEndpoints,
+  userEngagement: userEngagementEndpoints
+};
+
+// src/routing/router.ts
+var serviceInstances = {};
+var rpcClient;
+var unifiedClient;
+var endpointRegistry = /* @__PURE__ */ new Map();
+var endpointDefaultTransports = /* @__PURE__ */ new Map();
+var defaultTransport = "auto";
+var transportState = {
+  hasHttp: false,
+  hasWs: false,
+  hasGrpc: false
+};
+function resetRoutingState() {
+  serviceInstances = {};
+  rpcClient = void 0;
+  unifiedClient = void 0;
+  endpointRegistry.clear();
+  endpointDefaultTransports.clear();
+  defaultTransport = "auto";
+  transportState = { hasHttp: false, hasWs: false, hasGrpc: false };
+}
+function setServiceInstances(instances) {
+  serviceInstances = instances;
+}
+function setRpcClient(client) {
+  rpcClient = client;
+}
+function setUnifiedClient(client) {
+  unifiedClient = client;
+}
+function setTransportState(state) {
+  transportState = state;
+}
+function setDefaultTransport(transport) {
+  defaultTransport = transport;
+}
+function makeEndpointKey(service, functionName) {
+  return `${service}:${functionName}`;
+}
+function isEndpointSpec(value) {
+  return !!value && typeof value === "object" && "transport" in value;
+}
+function isEndpointGroup(value) {
+  return !!value && typeof value === "object" && "transports" in value;
+}
+function registerEndpointVariant(service, functionName, endpoint) {
+  const key = makeEndpointKey(service, functionName);
+  let byTransport = endpointRegistry.get(key);
+  if (!byTransport) {
+    byTransport = /* @__PURE__ */ new Map();
+    endpointRegistry.set(key, byTransport);
+  }
+  byTransport.set(endpoint.transport, endpoint);
+}
+function rebuildEndpointRegistry() {
+  endpointRegistry = /* @__PURE__ */ new Map();
+  endpointDefaultTransports = /* @__PURE__ */ new Map();
+  for (const [serviceName, service] of Object.entries(apiMap)) {
+    for (const [functionName, endpoint] of Object.entries(service)) {
+      if (isEndpointSpec(endpoint)) {
+        registerEndpointVariant(serviceName, functionName, endpoint);
+        continue;
+      }
+      if (isEndpointGroup(endpoint)) {
+        if (endpoint.defaultTransport) {
+          endpointDefaultTransports.set(
+            makeEndpointKey(serviceName, functionName),
+            endpoint.defaultTransport
+          );
+        }
+        for (const [transport, config] of Object.entries(endpoint.transports ?? {})) {
+          if (!config) continue;
+          if (transport === "http") {
+            registerEndpointVariant(serviceName, functionName, {
+              id: endpoint.id,
+              transport: "http",
+              http: config,
+              request: endpoint.request,
+              response: endpoint.response
+            });
+          } else if (transport === "ws") {
+            registerEndpointVariant(serviceName, functionName, {
+              id: endpoint.id,
+              transport: "ws",
+              ws: config,
+              request: endpoint.request,
+              response: endpoint.response
+            });
+          } else if (transport === "grpc") {
+            registerEndpointVariant(serviceName, functionName, {
+              id: endpoint.id,
+              transport: "grpc",
+              grpc: config,
+              request: endpoint.request,
+              response: endpoint.response
+            });
+          }
+        }
+        continue;
+      }
+    }
+  }
+}
+function requestApi(args) {
+  const key = makeEndpointKey(args.service, args.functionName);
+  const endpointVariants = endpointRegistry.get(key);
+  if (endpointVariants) {
+    if (!unifiedClient) {
+      throw new Error("SDK not initialized. Please call initSDK first.");
+    }
+    const specDefaultTransport = endpointDefaultTransports.get(key);
+    const endpoint = pickEndpoint(
+      endpointVariants,
+      args.transport,
+      specDefaultTransport,
+      args.service,
+      args.functionName
+    );
+    if (endpoint.transport === "grpc" && !transportState.hasGrpc) {
+      throw new Error("SDK not initialized. Please call initSDK with grpc config.");
+    }
+    if (endpoint.transport === "ws" && !transportState.hasWs) {
+      throw new Error("SDK not initialized. Please call initSDK with ws config.");
+    }
+    if (endpoint.transport === "http" && !transportState.hasHttp) {
+      throw new Error("SDK not initialized. Please call initSDK with http config.");
+    }
+    const meta = args.callOptions || args.wsOptions ? {
+      ...args.meta ?? {},
+      ...args.callOptions ? { callOptions: args.callOptions } : {},
+      ...args.wsOptions ? { wsOptions: args.wsOptions } : {}
+    } : args.meta;
+    return unifiedClient.call(endpoint, args.requestParam, meta);
+  }
+  const serviceInstance = serviceInstances[args.service];
+  const method = serviceInstance?.[args.functionName];
+  if (typeof method === "function") {
+    if (args.callOptions !== void 0) {
+      return method(args.requestParam, args.callOptions);
+    }
+    return method(args.requestParam);
+  }
+  if (!rpcClient) {
+    throw new Error("SDK not initialized. Please call initSDK first.");
+  }
+  return rpcClient.call(args.functionName, args.service, args.requestParam, args.wsOptions);
+}
+function pickEndpoint(variants, transport, specDefaultTransport, service, functionName) {
+  const resolvedTransport = transport ?? specDefaultTransport ?? defaultTransport;
+  if (resolvedTransport !== "auto") {
+    const found = variants.get(resolvedTransport);
+    if (!found) {
+      throw new Error(
+        `Endpoint transport not found: ${service}.${functionName} (${resolvedTransport}). Available: ${Array.from(
+          variants.keys()
+        ).join(", ")}`
+      );
+    }
+    return found;
+  }
+  if (transportState.hasGrpc && variants.has("grpc")) return variants.get("grpc");
+  if (transportState.hasWs && variants.has("ws")) return variants.get("ws");
+  if (transportState.hasHttp && variants.has("http")) return variants.get("http");
+  const fallback = variants.values().next().value;
+  if (!fallback) {
+    throw new Error(`Endpoint not found: ${service}.${functionName}`);
+  }
+  return fallback;
+}
+
+// src/utils/adapters/web.ts
+var webStorage = {
+  get(key) {
+    if (typeof window === "undefined") return null;
+    try {
+      const storage = window.localStorage;
+      if (!storage) return null;
+      return storage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  set(key, value) {
+    if (typeof window === "undefined") return;
+    try {
+      const storage = window.localStorage;
+      if (!storage) return;
+      storage.setItem(key, value);
+    } catch {
+      return;
+    }
+  }
 };
-var getLocalItem = (key) => {
-  if (typeof window !== "undefined") {
-    return window.localStorage.getItem(key);
+
+// src/utils/fetchGuid.ts
+var defaultKey = "uKey";
+var guidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var hex32Pattern = /^[0-9a-f]{32}$/i;
+function createFetchGuid(storage, options) {
+  return () => fetchGuidWithStorage(storage, options);
+}
+function fetchGuidWithStorage(storage, options) {
+  const key = options?.key ?? defaultKey;
+  const current = safeGet(storage, key);
+  if (current) {
+    const unmasked = unmaskGuid(current);
+    if (unmasked) return formatGuid(unmasked, options);
+  }
+  const guid = generateGuid();
+  safeSet(storage, key, maskGuid(guid));
+  return formatGuid(guid, options);
+}
+function safeGet(storage, key) {
+  try {
+    return storage.get(key);
+  } catch {
+    return null;
+  }
+}
+function safeSet(storage, key, value) {
+  try {
+    storage.set(key, value);
+  } catch {
+    return;
+  }
+}
+function generateGuid() {
+  const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (cryptoObj && cryptoObj.getRandomValues) {
+    return "10000000-1000-4000-8000-100000000000".replace(
+      /[018]/g,
+      (c) => (+c ^ cryptoObj.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
+    );
+  }
+  return "xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+    const r = Math.random() * 16 | 0;
+    const v = ch === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function maskGuid(guid) {
+  const hex = guid.replace(/-/g, "");
+  const buffer = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    buffer[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return base64Encode(buffer);
+}
+function unmaskGuid(value) {
+  const clean = value.replace(/"/g, "").trim();
+  if (guidPattern.test(clean)) return clean;
+  if (hex32Pattern.test(clean)) {
+    return clean.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+  }
+  const bytes = base64Decode(clean);
+  if (!bytes) return null;
+  const hex = Array.prototype.map.call(bytes, (byte) => ("0" + (byte & 255).toString(16)).slice(-2)).join("");
+  if (hex.length !== 32) return null;
+  return hex.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+}
+function formatGuid(guid, options) {
+  const format = options?.format ?? "uuid";
+  const prefix = options?.prefix ?? "";
+  if (format === "uuid") return prefix + guid;
+  const hex = guid.replace(/-/g, "");
+  if (format === "hex") return prefix + hex;
+  const buffer = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    buffer[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return prefix + base64Encode(buffer);
+}
+function base64Encode(bytes) {
+  const btoaFn = typeof globalThis !== "undefined" ? globalThis.btoa : void 0;
+  if (btoaFn) {
+    let binary = "";
+    for (let i2 = 0; i2 < bytes.length; i2++) binary += String.fromCharCode(bytes[i2]);
+    return btoaFn(binary);
+  }
+  const BufferCtor = typeof globalThis !== "undefined" ? globalThis.Buffer : void 0;
+  if (BufferCtor) return BufferCtor.from(bytes).toString("base64");
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let out = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const rem = bytes.length - i;
+    const b1 = bytes[i++];
+    const b2 = rem > 1 ? bytes[i++] : 0;
+    const b3 = rem > 2 ? bytes[i++] : 0;
+    const n = b1 << 16 | b2 << 8 | b3;
+    out += chars[n >> 18 & 63] + chars[n >> 12 & 63] + (rem > 1 ? chars[n >> 6 & 63] : "=") + (rem > 2 ? chars[n & 63] : "=");
+  }
+  return out;
+}
+function base64Decode(b64) {
+  const atobFn = typeof globalThis !== "undefined" ? globalThis.atob : void 0;
+  if (atobFn) {
+    try {
+      const bin = atobFn(b64);
+      const out = new Uint8Array(bin.length);
+      for (let i2 = 0; i2 < bin.length; i2++) out[i2] = bin.charCodeAt(i2);
+      return out;
+    } catch {
+      return null;
+    }
+  }
+  const BufferCtor = typeof globalThis !== "undefined" ? globalThis.Buffer : void 0;
+  if (BufferCtor) {
+    try {
+      const buf = BufferCtor.from(b64, "base64");
+      return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    } catch {
+      return null;
+    }
+  }
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const map = {};
+  for (let i2 = 0; i2 < chars.length; i2++) map[chars[i2]] = i2;
+  const clean = b64.replace(/[^A-Za-z0-9+/=]/g, "");
+  if (!clean) return null;
+  const bytes = [];
+  let i = 0;
+  while (i < clean.length) {
+    const c1 = clean[i++];
+    const c2 = clean[i++];
+    const c3 = clean[i++];
+    const c4 = clean[i++];
+    if (!c1 || !c2) break;
+    const e1 = map[c1];
+    const e2 = map[c2];
+    if (e1 === void 0 || e2 === void 0) return null;
+    const e3 = c3 === "=" || !c3 ? 0 : map[c3];
+    const e4 = c4 === "=" || !c4 ? 0 : map[c4];
+    if (e3 === void 0 || e4 === void 0) return null;
+    const n = e1 << 18 | e2 << 12 | e3 << 6 | e4;
+    const b1 = n >> 16 & 255;
+    const b2 = n >> 8 & 255;
+    const b3 = n & 255;
+    bytes.push(b1);
+    if (c3 !== "=") bytes.push(b2);
+    if (c4 !== "=") bytes.push(b3);
+  }
+  return new Uint8Array(bytes);
+}
+
+// src/utils/uniqueKey.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var memoryStorage = {
+  get(key) {
+    return memoryStore.get(key) ?? null;
+  },
+  set(key, val) {
+    memoryStore.set(key, val);
   }
 };
-var setLocalItem = (key, val) => {
-  if (typeof window !== "undefined") {
-    window.localStorage.setItem(key, val);
+var defaultStorage = {
+  get(key) {
+    return webStorage.get(key) ?? memoryStorage.get(key);
+  },
+  set(key, val) {
+    webStorage.set(key, val);
+    memoryStorage.set(key, val);
   }
 };
+var storageAdapter = defaultStorage;
+var fetchGuidImpl = createFetchGuid(storageAdapter);
+var setUniqueKeyStorage = (adapter) => {
+  storageAdapter = adapter ?? defaultStorage;
+  fetchGuidImpl = createFetchGuid(storageAdapter);
+};
+var fetchGuid = () => fetchGuidImpl();
 
 // src/index.ts
 var api;
@@ -4882,6 +6716,7 @@ function createApiServiceClient(service) {
 0 && (module.exports = {
   apiError,
   callApi,
+  createFetchGuid,
   destroySDK,
   fetchGuid,
   getSDK,
@@ -4889,6 +6724,8 @@ function createApiServiceClient(service) {
   initSDK,
   notify,
   requestApi,
-  requestApiSpec
+  requestApiSpec,
+  setUniqueKeyStorage,
+  webStorage
 });
 //# sourceMappingURL=index.cjs.map