@masterunoco/casinowebengine-api 0.1.0

package/dist/index.cjs

@@ -0,0 +1,902 @@
+'use strict';
+
+// src/errors.ts
+var ApiError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.name = "ApiError";
+    this.status = params.status;
+    this.url = params.url;
+    this.method = params.method;
+    this.payload = params.payload;
+    this.requestId = params.requestId ?? null;
+  }
+};
+function isApiError(err) {
+  return !!err && typeof err === "object" && err.name === "ApiError";
+}
+
+// src/http/client.ts
+var HttpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  setAuthProvider(auth) {
+    if (auth) {
+      this.opts.auth = auth;
+    }
+  }
+  async request(path, init = {}, authPolicy = "optional") {
+    const url = joinUrl(this.opts.baseUrl, path);
+    const method = (init.method || "GET").toUpperCase();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs ?? 15e3);
+    try {
+      const headers = new Headers(this.opts.defaultHeaders || {});
+      if (authPolicy !== "none") {
+        const token = this.opts.auth?.getToken?.() ?? null;
+        if (token) headers.set("Authorization", `JWT ${token}`);
+        if (authPolicy === "required" && !token) {
+          throw new ApiError({
+            status: 401,
+            url,
+            method,
+            message: "Authentication required",
+            payload: { code: "AUTH_REQUIRED" }
+          });
+        }
+      }
+      if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+      const res = await (this.opts.fetchFn ?? fetch)(url, {
+        ...init,
+        headers: { ...Object.fromEntries(headers.entries()), ...init.headers || {} },
+        signal: controller.signal
+      });
+      const reqId = res.headers.get("x-request-id") || res.headers.get("x-correlation-id") || null;
+      const contentType = res.headers.get("content-type") || "";
+      const isJson = contentType.includes("application/json");
+      if (!res.ok) {
+        const payload = await readBody(res, isJson);
+        const message = isJson && typeof payload === "object" && payload && ("message" in payload || "error" in payload) ? String(payload.message ?? payload.error) : res.statusText || `HTTP ${res.status}`;
+        throw new ApiError({
+          status: res.status,
+          url,
+          method,
+          message,
+          payload: (isJson ? payload : payload) ?? null,
+          requestId: reqId
+        });
+      }
+      if (isJson) return await res.json();
+      const text = await res.text();
+      return text ? text : null;
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        throw new ApiError({
+          status: 408,
+          url,
+          method,
+          message: "Request timeout",
+          payload: { code: "TIMEOUT" }
+        });
+      }
+      if (err instanceof ApiError) throw err;
+      throw new ApiError({
+        status: 0,
+        url,
+        method,
+        message: err?.message || "Network error",
+        payload: { code: "NETWORK_ERROR" }
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  get(path, authPolicy) {
+    return this.request(path, { method: "GET" }, authPolicy);
+  }
+  post(path, body, authPolicy) {
+    return this.request(
+      path,
+      { method: "POST", body: body !== void 0 ? JSON.stringify(body) : null },
+      authPolicy
+    );
+  }
+  patch(path, body, authPolicy) {
+    return this.request(
+      path,
+      { method: "PATCH", body: body !== void 0 ? JSON.stringify(body) : null },
+      authPolicy
+    );
+  }
+  delete(path, authPolicy) {
+    return this.request(path, { method: "DELETE" }, authPolicy);
+  }
+};
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}${path.startsWith("/") ? "" : "/"}${path}`;
+}
+async function readBody(res, isJson) {
+  try {
+    return isJson ? await res.json() : await res.text();
+  } catch {
+    return null;
+  }
+}
+
+// src/localStorage.ts
+var LocalStorage = class {
+  constructor() {
+    this.tokenKey = "gs.token";
+    this.userDataKey = "gs.userData";
+    this.avatarKey = "gs.avatar";
+    this.socketTokenKey = "gs.socketToken";
+    this.pinKey = "gs.pin";
+    this.pinTokenKey = "gs.pinToken";
+    this.geoLocalStorageKey = "gs.visitorLocation";
+  }
+  isLocalStorageAvailable() {
+    return typeof localStorage !== "undefined";
+  }
+  setToken(token) {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.setItem(this.tokenKey, token);
+    }
+  }
+  getToken() {
+    if (this.isLocalStorageAvailable()) {
+      return localStorage.getItem(this.tokenKey);
+    }
+    return null;
+  }
+  setUser(data) {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.setItem(this.userDataKey, JSON.stringify(data));
+    }
+  }
+  getUser() {
+    if (this.isLocalStorageAvailable()) {
+      const data = localStorage.getItem(this.userDataKey);
+      if (data) {
+        try {
+          return JSON.parse(data);
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  setAvatar(avatarUrl) {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.setItem(this.avatarKey, avatarUrl);
+    }
+  }
+  getAvatar() {
+    if (this.isLocalStorageAvailable()) {
+      return localStorage.getItem(this.avatarKey);
+    }
+    return null;
+  }
+  setSocketToken(token) {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.setItem(this.socketTokenKey, token);
+    }
+  }
+  getSocketToken() {
+    if (this.isLocalStorageAvailable()) {
+      return localStorage.getItem(this.socketTokenKey);
+    }
+    return null;
+  }
+  setPin(pin) {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.setItem(this.pinKey, pin);
+    }
+  }
+  getPin() {
+    if (this.isLocalStorageAvailable()) {
+      return localStorage.getItem(this.pinKey);
+    }
+    return null;
+  }
+  setPinToken(token) {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.setItem(this.pinTokenKey, token);
+    }
+  }
+  getPinToken() {
+    if (this.isLocalStorageAvailable()) {
+      return localStorage.getItem(this.pinTokenKey);
+    }
+    return null;
+  }
+  setGeolocation(data) {
+    if (this.isLocalStorageAvailable()) {
+      data.timestamp = Date.now();
+      localStorage.setItem(this.geoLocalStorageKey, JSON.stringify(data));
+    }
+  }
+  getGeolocation() {
+    if (this.isLocalStorageAvailable()) {
+      const data = localStorage.getItem(this.geoLocalStorageKey);
+      if (data) {
+        try {
+          const parsedData = JSON.parse(data);
+          if (parsedData.timestamp) {
+            const now = Date.now();
+            const age = now - parsedData.timestamp;
+            const cacheTime = 10 * 60 * 1e3;
+            if (age > cacheTime) {
+              return null;
+            }
+          }
+          return parsedData;
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  clear() {
+    if (this.isLocalStorageAvailable()) {
+      localStorage.removeItem(this.tokenKey);
+      localStorage.removeItem(this.userDataKey);
+      localStorage.removeItem(this.avatarKey);
+      localStorage.removeItem(this.socketTokenKey);
+      localStorage.removeItem(this.pinKey);
+      localStorage.removeItem(this.pinTokenKey);
+      localStorage.removeItem(this.geoLocalStorageKey);
+    }
+  }
+};
+var storage = new LocalStorage();
+
+// src/apis/geo.ts
+var GeolocationAPI = class {
+  constructor(http) {
+    this.http = http;
+    this.failObj = {
+      ip: "0.0.0.0",
+      countryCode: "undefined",
+      status: "fail",
+      message: "invalid query",
+      query: "undefined"
+    };
+  }
+  async getGeolocationFromAPI() {
+    try {
+      const geo = await this.http.get("/geo/location", "none");
+      if (geo.ipAddress && geo.ipVersion) {
+        delete geo.ipVersion;
+        delete geo.ipAddress;
+        storage.setGeolocation(geo);
+        return geo;
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  async getGeolocation() {
+    const geoData = storage.getGeolocation();
+    if (geoData) {
+      try {
+        const geo = JSON.parse(geoData);
+        if (geo && geo.ipVersion) {
+          delete geo.ipVersion;
+          delete geo.ipAddress;
+          return geo;
+        } else {
+          return this.failObj;
+        }
+      } catch {
+        return this.failObj;
+      }
+    } else {
+      return await this.getGeolocationFromAPI() || this.failObj;
+    }
+  }
+  async getCountryCode() {
+    const geo = await this.getGeolocation();
+    if (geo && geo.countryCode && geo.countryCode === "undefined") {
+      return geo.countryCode;
+    } else {
+      return false;
+    }
+  }
+};
+
+// src/auth/jwtAuth.ts
+var JwtAuth = class {
+  constructor(client) {
+    this.client = client;
+    this.token = null;
+    this.user = null;
+    this.token = storage.getToken();
+    this.user = storage.getUser();
+  }
+  setToken(token) {
+    if (token) {
+      storage.setToken(token);
+      this.token = token;
+    } else {
+      storage.clear();
+    }
+  }
+  setUser(user, token) {
+    storage.setUser(user);
+    storage.setToken(token);
+    this.user = user;
+    this.token = token;
+  }
+  async login(username, password, recaptchaToken) {
+    const authPolicy = "none";
+    const payload = { username, password, recaptchaToken };
+    const res = await this.client.post("/auth/login", payload, authPolicy);
+    this.setUser(res.user, res.token);
+    return res;
+  }
+  async GoogleLogin(data) {
+    const geo = new GeolocationAPI(this.client);
+    const geoData = await geo.getGeolocation();
+    if (geoData) {
+      data.geo = geoData;
+    }
+    const authPolicy = "none";
+    const res = await this.client.post("/auth/google/signin", data, authPolicy);
+    this.setUser(res.user, res.token);
+    return res;
+  }
+  async forgetPassword(email) {
+    const authPolicy = "none";
+    await this.client.post("/auth/forgot-password", { email }, authPolicy);
+  }
+  async register(data, param) {
+    const geo = new GeolocationAPI(this.client);
+    const geoData = await geo.getGeolocation();
+    if (geoData) {
+      data.geo = geoData;
+    }
+    let apiRouter = "/auth/signup";
+    if (param) {
+      apiRouter += `?ref=${param}`;
+    }
+    const authPolicy = "none";
+    const registerData = await this.client.post(apiRouter, data, authPolicy);
+    if (registerData.player) {
+      const loginData = await this.login(data.username, data.password, data.recaptchaToken);
+      return {
+        ...registerData,
+        ...loginData
+      };
+    } else {
+      return {
+        ...registerData
+      };
+    }
+  }
+  async registerV2(data, param) {
+    const geo = new GeolocationAPI(this.client);
+    const geoData = await geo.getGeolocation();
+    if (geoData) {
+      data.geo = geoData;
+    }
+    let apiRouter = "/auth/signupv2";
+    if (param) {
+      apiRouter += `?ref=${param}`;
+    }
+    const authPolicy = "none";
+    const registerData = await this.client.post(apiRouter, data, authPolicy);
+    if (registerData.player) {
+      const loginData = await this.login(data.username, data.password, data.recaptchaToken);
+      return {
+        ...registerData,
+        ...loginData
+      };
+    } else {
+      return {
+        ...registerData
+      };
+    }
+  }
+  async registerV2Validate(data) {
+    const authPolicy = "none";
+    return await this.client.post("/auth/signupv2/validate-username-email", data, authPolicy);
+  }
+  clear() {
+    this.setToken(null);
+    this.user = null;
+  }
+  async logout() {
+    const authPolicy = "required";
+    await this.client.post("/auth/logout", {}, authPolicy);
+    this.clear();
+  }
+  async pinCode(pin) {
+    const authPolicy = "none";
+    return await this.client.post("/auth/website", { pin }, authPolicy);
+  }
+  async pinCheck(token) {
+    const authPolicy = "none";
+    return await this.client.post("/auth/website/check", { token }, authPolicy);
+  }
+  getToken() {
+    if (!this.token) {
+      this.token = storage.getToken();
+    }
+    return this.token;
+  }
+  getUser() {
+    if (!this.user) {
+      this.user = storage.getUser();
+    }
+    return this.user;
+  }
+  isAuthenticated() {
+    const Token = this.token || this.getToken();
+    return !!Token;
+  }
+};
+
+// src/apis/affiliate.ts
+var AffiliateAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async generateReferralCode(description) {
+    return await this.http.post(`/referral/generate`, { description });
+  }
+  async getReferralCode() {
+    return await this.http.get(`/referral/get`);
+  }
+  async getReferralCount() {
+    return await this.http.get(`/referral/max-codes`);
+  }
+  async getReferralStatus() {
+    return await this.http.get(`/referral/status`);
+  }
+  async getReferralFriends(page, limit) {
+    return await this.http.get(`/referral/friends?page=${page}&limit=${limit}`);
+  }
+  async getBannerImage(lang, key) {
+    return await this.http.get(`/website-settings?language=${lang}&key=${key}`);
+  }
+  async getRewards() {
+    return await this.http.get(`/referral/rewards`);
+  }
+  async getAvailablePrizes() {
+    return await this.http.get(`/referral/available-prizes`);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async getPrizes(params) {
+    const queryParams = new URLSearchParams();
+    for (const key in params) {
+      if (params[key] !== void 0) {
+        queryParams.append(key, String(params[key]));
+      }
+    }
+    const query = queryParams.toString();
+    return await this.http.get(`/referral/prizes?${query}`);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async convert(data) {
+    return await this.http.post(`/referral/convert`, data);
+  }
+  async getSummary() {
+    return await this.http.get(`/referral/summary`);
+  }
+};
+
+// src/apis/content.ts
+var ContentAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list() {
+    return this.http.get("/content-pages", "none");
+  }
+  get(slug) {
+    return this.http.get(`/content-pages/${slug}`, "none");
+  }
+};
+
+// src/apis/deposit.ts
+var DepositAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  charge(data) {
+    return this.http.post("/deposit/charge", data, "required");
+  }
+  getPaymentMethods() {
+    return this.http.get("/payment-methods", "required");
+  }
+  getDeposits(status = "pending", page = 1, limit = 20) {
+    return this.http.get(`/payment/${status}?page=${page}&limit=${limit}`, "required");
+  }
+};
+
+// src/apis/games.ts
+var GamesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Public: search games */
+  search(request) {
+    return this.http.post("/games/search", request, "none");
+  }
+  getCategories() {
+    return this.http.get("/games/categories", "none");
+  }
+  /** Requires auth: player link */
+  getLink(gameId) {
+    return this.http.post(`/games/getLink`, { gameId }, "required");
+  }
+  /** Public: demo link */
+  getDemoLink(gameId) {
+    return this.http.post("/games/getDemoLink", { gameId }, "none");
+  }
+  setFavorite(gameId, isFavorite) {
+    return this.http.post("/games/favorites", { gameId, isFavorite }, "required");
+  }
+  getFavorite() {
+    return this.http.get("/games/player-favorites", "required");
+  }
+  getRecentBigWins(category) {
+    return this.http.get(`/games/recent-big-wins?category=${category}`, "none");
+  }
+  getRecent(page = 1, limit = 10) {
+    return this.http.get(`/games/recent?page=${page}&limit=${limit}`);
+  }
+  getGlobalFavorites() {
+    return this.http.get("/games/global-favorites", "none");
+  }
+  getTopRated() {
+    const geo = new GeolocationAPI(this.http);
+    const countryCode = geo.getCountryCode();
+    let url = "/games/top-rated";
+    if (countryCode) {
+      url += `?region=${countryCode}`;
+    }
+    return this.http.get(url, "none");
+  }
+  getProviders() {
+    return this.http.get("/games/providers", "none");
+  }
+  getLobby() {
+    const geo = new GeolocationAPI(this.http);
+    const countryCode = geo.getCountryCode();
+    let url = "/games/lobby";
+    if (countryCode) {
+      url += `?region=${countryCode}`;
+    }
+    return this.http.get(url, "none");
+  }
+};
+
+// src/apis/luckyWheel.ts
+var LuckyWheelAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getStatistics() {
+    return this.http.get("/lucky-wheel/statistics", "required");
+  }
+  getWinners() {
+    return this.http.get("/lucky-wheel/get-winners?offset=1&limit=100", "none");
+  }
+  getPrizes() {
+    return this.http.get("/lucky-wheel/get-prizes");
+  }
+  getStatus() {
+    return this.http.get("/lucky-wheel/status");
+  }
+  play(data) {
+    return this.http.post("/lucky-wheel/play", data);
+  }
+  collect(data) {
+    return this.http.post("/lucky-wheel/collect", data);
+  }
+};
+
+// src/apis/media.ts
+var MediaAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  upload(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("upload_preset", "demo");
+    return this.http.post("/media/upload", formData, "none");
+  }
+  getFileUrl(filePath) {
+    return this.http.get(`/media/get-file-url?filePath=${filePath}`);
+  }
+};
+
+// src/apis/player.ts
+var PlayerAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  changePassword(data) {
+    return this.http.post("/player/change-password", data);
+  }
+  getBalanceHistory(data) {
+    const queryParams = new URLSearchParams();
+    if (data.limit !== void 0) queryParams.append("limit", data.limit.toString());
+    if (data.startDate !== void 0) queryParams.append("startDate", data.startDate);
+    if (data.endDate !== void 0) queryParams.append("endDate", data.endDate);
+    const queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
+    return this.http.get(`/player/balance-history${queryString}`);
+  }
+  getGameHistory(data) {
+    const queryParams = new URLSearchParams();
+    if (data.limit !== void 0) queryParams.append("limit", data.limit.toString());
+    if (data.startDate !== void 0) queryParams.append("startDate", data.startDate);
+    if (data.endDate !== void 0) queryParams.append("endDate", data.endDate);
+    const queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
+    return this.http.get(`/player/game-transaction${queryString}`);
+  }
+  verifyEmail(data) {
+    return this.http.post("/verify/email/send", data);
+  }
+  verifyEmailCode(data) {
+    return this.http.post("/verify/email/confirm", data);
+  }
+  verifyPhone(data) {
+    return this.http.post("/verify/phone/send", data);
+  }
+  verifyPhoneCode(data) {
+    return this.http.post("/verify/phone/confirm", data);
+  }
+  getVerificationStatus() {
+    return this.http.get("/player/verification-status");
+  }
+  getAvatars() {
+    return this.http.get("/avatars/get");
+  }
+  changeAvatar(data) {
+    return this.http.post("/avatars/set", data);
+  }
+  getPlayerKycDocuments() {
+    return this.http.get("/player/kyc-documents");
+  }
+  createPlayerKycDocument(data) {
+    return this.http.post("/player/kyc-documents", data);
+  }
+  createPlayerTags(data) {
+    const requestData = {
+      tags: data
+    };
+    return this.http.post("/player/tags", requestData);
+  }
+  updateProfile(data) {
+    return this.http.patch("/player/profile", data);
+  }
+};
+
+// src/apis/promotions.ts
+var PromotionsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getActive() {
+    return this.http.get("/promotions/active");
+  }
+  getPublic() {
+    return this.http.get("/promotions/public", "none");
+  }
+  getPromotion(id) {
+    return this.http.get(`/promotions/${id}`, "none");
+  }
+  getProgress() {
+    return this.http.get("/promotions/progress");
+  }
+  activateBonus(id) {
+    return this.http.post(`/bonus/activate/${id}`, {});
+  }
+  cancelBonus(id) {
+    return this.http.delete(`/bonus/cancel/${id}`);
+  }
+};
+
+// src/apis/raffle.ts
+var RaffleAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getTickets() {
+    return this.http.get("/raffle/tickets");
+  }
+  getPrizes() {
+    return this.http.get("/raffle/prizes");
+  }
+  getHistory() {
+    return this.http.get("/raffle/history");
+  }
+  getActiveRaffle() {
+    return this.http.get("/raffle/current");
+  }
+  purchaseTickets(data) {
+    return this.http.post("/raffle/purchase", data);
+  }
+};
+
+// src/apis/region.ts
+var RegionAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getDepositRegions() {
+    return this.http.get("/regions/deposit");
+  }
+  getWithdrawRegions() {
+    return this.http.get("/regions/withdraw");
+  }
+  getRegions() {
+    return this.http.get("/regions", "none");
+  }
+  getBlockedCountries() {
+    return this.http.get("/regions/blocked-countries", "none");
+  }
+};
+
+// src/apis/settings.ts
+var SettingsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getSettings() {
+    return this.http.get("/api/v1/settings", "none");
+  }
+  getBanner(lang) {
+    return this.http.get(`/banners/get/${lang}`, "none");
+  }
+  getContent() {
+    return this.http.get("/content-pages", "none");
+  }
+  getContentItem(type, lang) {
+    return this.http.get(`/content-pages/${type}/${lang}`, "none");
+  }
+  getAvatar() {
+    return this.http.get("/avatars/get", "none");
+  }
+  getPreferences() {
+    return this.http.get("/player/preferences");
+  }
+  updatePreferences(data) {
+    return this.http.patch("/player/preferences", data);
+  }
+  getCurrencies() {
+    return this.http.get("/currencies/get", "none");
+  }
+  getWebSetting(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=footerCasinoItems&key[]=footerSportsItems&key[]=footerSocialMedia&key[]=footerPromoItems&key[]=footerSupportLegalItems&key[]=footerAboutUsItems&key[]=footerAppLinks`, "none");
+  }
+  getWebSettingProviders(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=sectionProviders`, "none");
+  }
+  getWebSettingPin() {
+    return this.http.get(`/website-settings?key[]=isCodeProtected`, "none");
+  }
+  getWebSettingReferralRules(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=referral_rules`, "none");
+  }
+  getWebSettingReferralFaq(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=referral_faq`, "none");
+  }
+  getWebSettingReferralLearnMore(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=referral_learn_more`, "none");
+  }
+  getWebSettingReferralBanners(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=referral_assets`, "none");
+  }
+  getWebSettingSlotsCategories(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=slotsCategories`, "none");
+  }
+  getWebSettingLiveCasinoCategories(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=liveCasinoCategories`, "none");
+  }
+  getWebsiteAllowedPlayerTags(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=allowedPlayerTags`, "none");
+  }
+  getSupportEmail(lang) {
+    return this.http.get(`/website-settings?language=${lang}&key[]=supportEmail`, "none");
+  }
+};
+
+// src/apis/sport.ts
+var SportAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getConfig() {
+    return this.http.get("/sport/get-sport-config");
+  }
+};
+
+// src/apis/voucher.ts
+var VoucherAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  redeemVoucher(code) {
+    return this.http.post("/vouchers/redeem", { code });
+  }
+  checkVoucher(code) {
+    return this.http.get(`/vouchers/check/${code}`, "none");
+  }
+};
+
+// src/apis/withdraw.ts
+var WithdrawAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getWithdraws(status) {
+    const statusQuery = status ? `/${status}` : "";
+    return this.http.get(`/withdraw${statusQuery}`);
+  }
+  getWithdrawMethods() {
+    return this.http.get("/withdraw/methods", "none");
+  }
+  withdraw(data) {
+    return this.http.post("/withdraw", data);
+  }
+  rejectWithdraw(withdrawId) {
+    return this.http.post(`/withdraw/cancel`, { withdrawId });
+  }
+  getTrinkparaWithdrawInfo(info) {
+    return this.http.get(`/trinkpara/info?info=${info}`);
+  }
+  getAnindaBankList(methodId) {
+    return this.http.get(`/aninda/banks?paymentMethodId=${methodId}`);
+  }
+};
+
+// src/sdk.ts
+var GameSDK = class {
+  constructor(cfg) {
+    this.http = new HttpClient({
+      baseUrl: cfg.baseUrl.replace(/\/+$/, ""),
+      auth: { getToken: () => this.auth.getToken() },
+      // <-- uses this.auth (defined below)
+      timeoutMs: cfg.timeoutMs ?? 15e3
+    });
+    this.auth = new JwtAuth(this.http);
+    this.affiliate = new AffiliateAPI(this.http);
+    this.content = new ContentAPI(this.http);
+    this.deposit = new DepositAPI(this.http);
+    this.games = new GamesAPI(this.http);
+    this.geolocation = new GeolocationAPI(this.http);
+    this.luckyWheel = new LuckyWheelAPI(this.http);
+    this.media = new MediaAPI(this.http);
+    this.player = new PlayerAPI(this.http);
+    this.promotions = new PromotionsAPI(this.http);
+    this.raffle = new RaffleAPI(this.http);
+    this.region = new RegionAPI(this.http);
+    this.settings = new SettingsAPI(this.http);
+    this.sport = new SportAPI(this.http);
+    this.voucher = new VoucherAPI(this.http);
+    this.withdraw = new WithdrawAPI(this.http);
+  }
+};
+var createGameSDK = (cfg) => new GameSDK(cfg);
+
+// src/types/auth.ts
+var USERNAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+
+exports.ApiError = ApiError;
+exports.ContentAPI = ContentAPI;
+exports.GameSDK = GameSDK;
+exports.GamesAPI = GamesAPI;
+exports.JwtAuth = JwtAuth;
+exports.PromotionsAPI = PromotionsAPI;
+exports.USERNAME_REGEX = USERNAME_REGEX;
+exports.createGameSDK = createGameSDK;
+exports.isApiError = isApiError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map