@accelbyte/sdk 0.0.0-dev-20240828032938 → 0.0.0-dev-20240828053809

package/dist/cjs/node/index.cjs

@@ -0,0 +1,752 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.node.ts
+var index_node_exports = {};
+__export(index_node_exports, {
+  AccelByte: () => AccelByte,
+  AccelByteSDK: () => AccelByteSDK,
+  ApiUtils: () => ApiUtils,
+  AuthInterceptors: () => AuthInterceptors,
+  BrowserHelper: () => BrowserHelper,
+  CodeGenUtil: () => CodeGenUtil,
+  DecodeError: () => DecodeError,
+  DesktopChecker: () => DesktopChecker,
+  ERROR_CODE_LINK_DELETION_ACCOUNT: () => ERROR_CODE_LINK_DELETION_ACCOUNT,
+  ERROR_CODE_TOKEN_EXPIRED: () => ERROR_CODE_TOKEN_EXPIRED,
+  ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT: () => ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT,
+  ERROR_USER_BANNED: () => ERROR_USER_BANNED,
+  ErrorInterceptors: () => ErrorInterceptors,
+  IamErrorCode: () => IamErrorCode,
+  Network: () => Network,
+  RefreshSession: () => RefreshSession,
+  SdkDevice: () => SdkDevice,
+  UrlHelper: () => UrlHelper,
+  Validate: () => Validate,
+  doRefreshSession: () => doRefreshSession,
+  refreshWithLock: () => refreshWithLock
+});
+module.exports = __toCommonJS(index_node_exports);
+
+// src/polyfills/node.ts
+var import_crypto = require("crypto");
+if (!global.crypto) {
+  global.crypto = import_crypto.webcrypto;
+}
+
+// src/utils/Network.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_query_string = __toESM(require("query-string"), 1);
+
+// src/utils/SdkDevice.ts
+var uuid = __toESM(require("uuid"), 1);
+var _SdkDevice = class _SdkDevice {
+};
+_SdkDevice.ID_KEY = "deviceId";
+_SdkDevice.TYPE = {
+  MOBILE: "mobile",
+  DESKTOP: "desktop"
+};
+_SdkDevice.getType = () => {
+  return isMobile() ? _SdkDevice.TYPE.MOBILE : _SdkDevice.TYPE.DESKTOP;
+};
+_SdkDevice.generateUUID = () => {
+  const deviceIdInUUID = uuid.v4().split("-").join("");
+  localStorage.setItem(_SdkDevice.ID_KEY, deviceIdInUUID);
+  return deviceIdInUUID;
+};
+_SdkDevice.getDeviceId = () => {
+  return localStorage.getItem(_SdkDevice.ID_KEY) || _SdkDevice.generateUUID();
+};
+var SdkDevice = _SdkDevice;
+var mobileRE = /(android|bb\d+|meego).+mobile|armv7l|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+var tabletRE = /android|ipad|playbook|silk/i;
+var isMobile = (opts) => {
+  if (!opts) opts = {};
+  let ua = opts.ua;
+  if (!ua && typeof navigator !== "undefined") ua = navigator.userAgent;
+  if (ua && ua.headers && typeof ua.headers["user-agent"] === "string") {
+    ua = ua.headers["user-agent"];
+  }
+  if (typeof ua !== "string") return false;
+  let result = mobileRE.test(ua) || !!opts.tablet && tabletRE.test(ua);
+  if (!result && opts.tablet && opts.featureDetect && navigator && navigator.maxTouchPoints > 1 && ua.indexOf("Macintosh") !== -1 && ua.indexOf("Safari") !== -1) {
+    result = true;
+  }
+  return result;
+};
+
+// src/utils/Network.ts
+var _Network = class _Network {
+  static create(...configs) {
+    const axiosInstance = import_axios.default.create(
+      Object.assign(
+        {
+          paramsSerializer: import_query_string.default.stringify
+        },
+        ...configs
+      )
+    );
+    return axiosInstance;
+  }
+  static withBearerToken(accessToken, config) {
+    return _Network.create(config || {}, {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+  }
+};
+_Network.setDeviceTokenCookie = () => {
+  const deviceId = SdkDevice.getDeviceId();
+  document.cookie = `device_token=${deviceId}; path=/;`;
+};
+_Network.removeDeviceTokenCookie = () => {
+  document.cookie = `device_token=; expires=${(/* @__PURE__ */ new Date(0)).toUTCString()}`;
+};
+_Network.getFormUrlEncodedData = (data) => {
+  const formPayload = new URLSearchParams();
+  const formKeys = Object.keys(data);
+  formKeys.forEach((key) => {
+    if (data[key]) formPayload.append(key, data[key]);
+  });
+  return formPayload;
+};
+var Network = _Network;
+
+// src/AccelByteSDK.ts
+var AccelByte = {
+  SDK: (param) => {
+    return new AccelByteSDK(param);
+  }
+};
+var AccelByteSDK = class _AccelByteSDK {
+  constructor({ coreConfig, axiosConfig }) {
+    var _a;
+    this.coreConfig = {
+      ...coreConfig,
+      useSchemaValidation: coreConfig.useSchemaValidation ?? true
+    };
+    this.axiosConfig = {
+      /**
+       * when user create a variable to store intercepters and passed into sdk
+       * the sdk will use the variable as reference value,
+       * so when new interceptor added, reference value will also has the new interceptor,
+       * to avoid this we create shallow copy for the interceptors
+       */
+      interceptors: (axiosConfig == null ? void 0 : axiosConfig.interceptors) ? [...axiosConfig.interceptors] : void 0,
+      request: {
+        timeout: 6e4,
+        withCredentials: true,
+        ...axiosConfig == null ? void 0 : axiosConfig.request,
+        headers: {
+          "Content-Type": "application/json",
+          ...(_a = axiosConfig == null ? void 0 : axiosConfig.request) == null ? void 0 : _a.headers
+        }
+      }
+    };
+    this.axiosInstance = Network.create({ baseURL: coreConfig.baseURL, ...this.axiosConfig.request });
+  }
+  assembly() {
+    return {
+      axiosInstance: this.axiosInstance,
+      coreConfig: this.coreConfig,
+      axiosConfig: this.axiosConfig
+    };
+  }
+  clone(opts) {
+    const newConfigs = {
+      coreConfig: { ...this.coreConfig },
+      axiosConfig: { ...this.axiosConfig }
+    };
+    if ((opts == null ? void 0 : opts.interceptors) === false) {
+      delete newConfigs.axiosConfig.interceptors;
+    }
+    return new _AccelByteSDK(newConfigs);
+  }
+  addInterceptors(interceptors) {
+    if (!this.axiosConfig.interceptors) {
+      this.axiosConfig.interceptors = [];
+    }
+    this.axiosConfig.interceptors.push(...interceptors);
+    return this;
+  }
+  removeInterceptors(filterCallback) {
+    var _a;
+    if (!((_a = this.axiosConfig) == null ? void 0 : _a.interceptors)) return this;
+    if (!filterCallback) {
+      this.axiosConfig.interceptors = void 0;
+      return this;
+    }
+    this.axiosConfig.interceptors = this.axiosConfig.interceptors.filter(filterCallback);
+    return this;
+  }
+  setConfig({ coreConfig, axiosConfig }) {
+    this.coreConfig = {
+      ...this.coreConfig,
+      ...coreConfig
+    };
+    this.axiosConfig = {
+      ...this.axiosConfig,
+      ...axiosConfig
+    };
+    return this;
+  }
+};
+
+// src/constants/IamErrorCode.ts
+var IamErrorCode = /* @__PURE__ */ ((IamErrorCode2) => {
+  IamErrorCode2[IamErrorCode2["InternalServerError"] = 2e4] = "InternalServerError";
+  IamErrorCode2[IamErrorCode2["UnauthorizedAccess"] = 20001] = "UnauthorizedAccess";
+  IamErrorCode2[IamErrorCode2["ValidationError"] = 20002] = "ValidationError";
+  IamErrorCode2[IamErrorCode2["ForbiddenAccess"] = 20003] = "ForbiddenAccess";
+  IamErrorCode2[IamErrorCode2["TooManyRequests"] = 20007] = "TooManyRequests";
+  IamErrorCode2[IamErrorCode2["UserNotFound"] = 20008] = "UserNotFound";
+  IamErrorCode2[IamErrorCode2["TokenIsExpired"] = 20011] = "TokenIsExpired";
+  IamErrorCode2[IamErrorCode2["InsufficientPermissions"] = 20013] = "InsufficientPermissions";
+  IamErrorCode2[IamErrorCode2["InvalidAudience"] = 20014] = "InvalidAudience";
+  IamErrorCode2[IamErrorCode2["InsufficientScope"] = 20015] = "InsufficientScope";
+  IamErrorCode2[IamErrorCode2["UnableToParseRequestBody"] = 20019] = "UnableToParseRequestBody";
+  IamErrorCode2[IamErrorCode2["InvalidPaginationParameters"] = 20021] = "InvalidPaginationParameters";
+  IamErrorCode2[IamErrorCode2["TokenIsNotUserToken"] = 20022] = "TokenIsNotUserToken";
+  IamErrorCode2[IamErrorCode2["InvalidRefererHeader"] = 20023] = "InvalidRefererHeader";
+  IamErrorCode2[IamErrorCode2["SubdomainMismatch"] = 20030] = "SubdomainMismatch";
+  return IamErrorCode2;
+})(IamErrorCode || {});
+
+// src/constants/LinkAccount.ts
+var ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT = 10200;
+var ERROR_CODE_LINK_DELETION_ACCOUNT = 10135;
+var ERROR_CODE_TOKEN_EXPIRED = 10196;
+var ERROR_USER_BANNED = 10134;
+
+// src/interceptors/AuthInterceptors.ts
+var import_axios2 = __toESM(require("axios"), 1);
+
+// src/utils/DesktopChecker.ts
+var _DesktopChecker = class _DesktopChecker {
+  static isDesktopApp() {
+    return _DesktopChecker.desktopApp && !_DesktopChecker.isInIframe();
+  }
+  static isInIframe() {
+    try {
+      return window.self !== window.top;
+    } catch (error) {
+      return true;
+    }
+  }
+  // borrowed from https://github.com/cheton/is-electron
+  static isElectron() {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && typeof process.versions === "object" && !!process.versions.electron) {
+      return true;
+    }
+    if (typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent.indexOf("Electron") >= 0) {
+      return true;
+    }
+    return false;
+  }
+};
+_DesktopChecker.desktopApp = _DesktopChecker.isElectron();
+var DesktopChecker = _DesktopChecker;
+
+// src/utils/BrowserHelper.ts
+var BrowserHelper = class {
+};
+BrowserHelper.isOnBrowser = () => {
+  return typeof window !== "undefined" && window.document;
+};
+
+// src/utils/RefreshSession.ts
+var _RefreshSession = class _RefreshSession {
+};
+// --
+_RefreshSession.KEY = "RefreshSession.lock";
+_RefreshSession.isLocked = () => {
+  if (!BrowserHelper.isOnBrowser()) return false;
+  const lockStatus = localStorage.getItem(_RefreshSession.KEY);
+  if (!lockStatus) {
+    return false;
+  }
+  const lockExpiry = Number(lockStatus);
+  if (isNaN(lockExpiry)) {
+    return false;
+  }
+  return lockExpiry > (/* @__PURE__ */ new Date()).getTime();
+};
+_RefreshSession.lock = (expiry) => {
+  if (!BrowserHelper.isOnBrowser()) return;
+  localStorage.setItem(_RefreshSession.KEY, `${(/* @__PURE__ */ new Date()).getTime() + expiry}`);
+};
+_RefreshSession.unlock = () => {
+  if (!BrowserHelper.isOnBrowser()) return;
+  localStorage.removeItem(_RefreshSession.KEY);
+};
+_RefreshSession.sleepAsync = (timeInMs) => new Promise((resolve) => setTimeout(resolve, timeInMs));
+_RefreshSession.isBearerAuth = (config) => {
+  var _a, _b;
+  if (((_b = (_a = config == null ? void 0 : config.headers) == null ? void 0 : _a.Authorization) == null ? void 0 : _b.toLowerCase().indexOf("bearer")) > -1) {
+    return true;
+  }
+  return false;
+};
+var RefreshSession = _RefreshSession;
+
+// ../sdk-iam/src/generated-definitions/TokenWithDeviceCookieResponseV3.ts
+var import_zod4 = require("zod");
+
+// ../sdk-iam/src/generated-definitions/JwtBanV3.ts
+var import_zod = require("zod");
+var JwtBanV3 = import_zod.z.object({
+  ban: import_zod.z.string(),
+  disabledDate: import_zod.z.string().nullish(),
+  enabled: import_zod.z.boolean(),
+  endDate: import_zod.z.string(),
+  targetedNamespace: import_zod.z.string()
+});
+
+// ../sdk-iam/src/generated-definitions/NamespaceRole.ts
+var import_zod2 = require("zod");
+var NamespaceRole = import_zod2.z.object({ namespace: import_zod2.z.string(), roleId: import_zod2.z.string() });
+
+// ../sdk-iam/src/generated-definitions/PermissionV3.ts
+var import_zod3 = require("zod");
+var PermissionV3 = import_zod3.z.object({
+  action: import_zod3.z.number().int(),
+  resource: import_zod3.z.string(),
+  schedAction: import_zod3.z.number().int().nullish(),
+  schedCron: import_zod3.z.string().nullish(),
+  schedRange: import_zod3.z.array(import_zod3.z.string()).nullish()
+});
+
+// ../sdk-iam/src/generated-definitions/TokenWithDeviceCookieResponseV3.ts
+var TokenWithDeviceCookieResponseV3 = import_zod4.z.object({
+  access_token: import_zod4.z.string(),
+  auth_trust_id: import_zod4.z.string().nullish(),
+  bans: import_zod4.z.array(JwtBanV3).nullish(),
+  display_name: import_zod4.z.string().nullish(),
+  expires_in: import_zod4.z.number().int(),
+  is_comply: import_zod4.z.boolean().nullish(),
+  jflgs: import_zod4.z.number().int().nullish(),
+  namespace: import_zod4.z.string(),
+  namespace_roles: import_zod4.z.array(NamespaceRole).nullish(),
+  permissions: import_zod4.z.array(PermissionV3),
+  platform_id: import_zod4.z.string().nullish(),
+  platform_user_id: import_zod4.z.string().nullish(),
+  refresh_expires_in: import_zod4.z.number().int().nullish(),
+  refresh_token: import_zod4.z.string().nullish(),
+  roles: import_zod4.z.array(import_zod4.z.string()).nullish(),
+  scope: import_zod4.z.string(),
+  simultaneous_platform_id: import_zod4.z.string().nullish(),
+  simultaneous_platform_user_id: import_zod4.z.string().nullish(),
+  token_type: import_zod4.z.string(),
+  unique_display_name: import_zod4.z.string().nullish(),
+  user_id: import_zod4.z.string().nullish(),
+  xuid: import_zod4.z.string().nullish()
+});
+
+// src/utils/CodeGenUtil.ts
+var CodeGenUtil = class {
+  /**
+   * Returns a hash code from a string
+   * @param  {String} str The string to hash.
+   * @return {Number} A 32bit integer
+   * @see http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
+   */
+  static hashCode(str) {
+    let hash = 0;
+    for (let i = 0, len = str.length; i < len; i++) {
+      const chr = str.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash |= 0;
+    }
+    return hash;
+  }
+};
+CodeGenUtil.getFormUrlEncodedData = (data) => {
+  const formPayload = new URLSearchParams();
+  const formKeys = Object.keys(data);
+  formKeys.forEach((key) => {
+    if (typeof data[key] !== "undefined") formPayload.append(key, data[key]);
+  });
+  return formPayload;
+};
+
+// src/utils/Validate.ts
+var Validate = class _Validate {
+  static validateOrReturnResponse(useSchemaValidation, networkCall, Codec, modelName) {
+    return useSchemaValidation ? _Validate.responseType(() => networkCall(), Codec, modelName) : _Validate.unsafeResponse(() => networkCall());
+  }
+  static responseType(networkCall, Codec, modelName) {
+    return wrapNetworkCallSafely(async () => {
+      const response = await networkCall();
+      const decodeResult = Codec.safeParse(response.data);
+      if (!decodeResult.success && response.status !== 204) {
+        throw new DecodeError({ error: decodeResult.error, response, modelName });
+      }
+      return response;
+    });
+  }
+  static unsafeResponse(networkCall) {
+    return wrapNetworkCallSafely(() => networkCall());
+  }
+  static safeParse(data, Codec) {
+    const result = Codec.safeParse(data);
+    if (result.success) {
+      return result.data;
+    }
+    return null;
+  }
+};
+async function wrapNetworkCallSafely(networkCallFunction) {
+  try {
+    const response = await networkCallFunction();
+    return { response, error: null };
+  } catch (error) {
+    return { response: null, error };
+  }
+}
+var DecodeError = class extends Error {
+  constructor({ error, response, modelName }) {
+    const msg = `response from url "${response.config.url}" doesn't match model "${modelName}"`;
+    super(msg);
+    console.error(msg, error);
+  }
+};
+
+// src/interceptors/AuthInterceptorDeps.ts
+var OAuth20$ = class {
+  // @ts-ignore
+  constructor(axiosInstance, namespace) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+  }
+  postOauthToken(data) {
+    const params = {};
+    const url = "/iam/v3/oauth/token";
+    const resultPromise = this.axiosInstance.post(url, CodeGenUtil.getFormUrlEncodedData(data), {
+      ...params,
+      headers: { ...params.headers, "content-type": "application/x-www-form-urlencoded" }
+    });
+    return Validate.responseType(() => resultPromise, TokenWithDeviceCookieResponseV3, "TokenWithDeviceCookieResponseV3");
+  }
+};
+
+// src/interceptors/AuthInterceptors.ts
+var REFRESH_EXPIRY = 1e3;
+var REFRESH_EXPIRY_UPDATE_RATE = 500;
+var REFRESH_EXPIRY_CHECK_RATE = 1e3;
+var LoginUrls = /* @__PURE__ */ ((LoginUrls2) => {
+  LoginUrls2["GRANT_TOKEN"] = "/iam/v3/oauth/token";
+  LoginUrls2["REVOKE"] = "/iam/v3/oauth/revoke";
+  return LoginUrls2;
+})(LoginUrls || {});
+var refreshSession = ({ axiosConfig, refreshToken, clientId }) => {
+  const config = {
+    ...axiosConfig,
+    withCredentials: false,
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${Buffer.from(`${clientId}:`).toString("base64")}`
+    }
+  };
+  const axios4 = Network.create(config);
+  const payload = {
+    refresh_token: refreshToken || void 0,
+    client_id: clientId,
+    grant_type: "refresh_token"
+  };
+  const oauth20 = new OAuth20$(axios4, "NAMESPACE-NOT-REQUIRED");
+  return oauth20.postOauthToken(payload);
+};
+var refreshWithLock = ({
+  axiosConfig,
+  refreshToken,
+  clientId
+}) => {
+  if (RefreshSession.isLocked()) {
+    return Promise.resolve().then(async () => {
+      while (RefreshSession.isLocked()) {
+        await RefreshSession.sleepAsync(REFRESH_EXPIRY_CHECK_RATE);
+      }
+      return {};
+    });
+  }
+  RefreshSession.lock(REFRESH_EXPIRY);
+  let isLocallyRefreshingToken = true;
+  (async () => {
+    while (isLocallyRefreshingToken) {
+      RefreshSession.lock(REFRESH_EXPIRY);
+      await RefreshSession.sleepAsync(REFRESH_EXPIRY_UPDATE_RATE);
+    }
+  })();
+  return Promise.resolve().then(doRefreshSession({ axiosConfig, clientId, refreshToken })).finally(() => {
+    isLocallyRefreshingToken = false;
+    RefreshSession.unlock();
+  });
+};
+var doRefreshSession = ({ axiosConfig, clientId, refreshToken }) => async () => {
+  if (DesktopChecker.isDesktopApp() && !axiosConfig.withCredentials && !refreshToken) {
+    return false;
+  }
+  const result = await refreshSession({ axiosConfig, clientId, refreshToken });
+  if (result.error) {
+    return false;
+  }
+  return result.response.data;
+};
+var uponRefreshComplete = (error, tokenResponse, onSessionExpired, axiosConfig, errorConfig) => {
+  if (tokenResponse) {
+    const { access_token } = tokenResponse;
+    if (!axiosConfig.withCredentials && access_token) {
+      return (0, import_axios2.default)({
+        ...errorConfig,
+        headers: {
+          ...errorConfig.headers,
+          Authorization: `Bearer ${access_token}`
+        }
+      });
+    } else {
+      return (0, import_axios2.default)(errorConfig);
+    }
+  }
+  if (onSessionExpired) {
+    onSessionExpired();
+  }
+  throw error;
+};
+var AuthInterceptors = [
+  {
+    type: "request",
+    name: "refresh-session",
+    onError: (error) => Promise.reject(error),
+    onRequest: async (config) => {
+      const isRefreshTokenUrl = config.url === "/iam/v3/oauth/token" /* GRANT_TOKEN */;
+      while (RefreshSession.isLocked() && !isRefreshTokenUrl) {
+        await RefreshSession.sleepAsync(200);
+      }
+      return config;
+    }
+  },
+  {
+    type: "response",
+    name: "get-session",
+    onError: (error) => Promise.reject(error),
+    onSuccess: (response) => {
+      const { config, status } = response;
+      if (config.url === "/iam/v3/oauth/token" /* GRANT_TOKEN */ && status === 200) {
+        const { access_token, refresh_token } = response.data;
+        if (access_token) {
+        }
+      }
+      return response;
+    }
+  },
+  {
+    type: "response",
+    name: "cancelled",
+    onError: (e) => {
+      const error = e;
+      if (import_axios2.default.isCancel(error)) {
+        return Promise.reject(error);
+      }
+      return Promise.reject(error);
+    }
+  },
+  {
+    type: "response",
+    name: "disconnected",
+    onError: (e) => {
+      const error = e;
+      const { config, response } = error;
+      if (!response) {
+        console.warn(`sdk:ERR_INTERNET_DISCONNECTED ${config == null ? void 0 : config.baseURL}${config == null ? void 0 : config.url}. ${error.message}
+`);
+      }
+      return Promise.reject(error);
+    }
+  },
+  {
+    type: "response",
+    name: "session-expired",
+    onError: (e) => {
+      const error = e;
+      const { config, response } = error;
+      if ((response == null ? void 0 : response.status) === 401) {
+        const { url } = config || {};
+        const clientId = "";
+        const axiosConfig = config;
+        const refreshToken = void 0;
+        if (Object.values(LoginUrls).includes(url)) {
+          return Promise.reject(error);
+        }
+        return refreshWithLock({ axiosConfig, clientId, refreshToken }).then((tokenResponse) => {
+          return uponRefreshComplete(
+            error,
+            tokenResponse,
+            () => {
+            },
+            axiosConfig,
+            config || {}
+          );
+        });
+      }
+      return Promise.reject(error);
+    }
+  }
+];
+
+// src/interceptors/ErrorInterceptor.ts
+var ERROR_ELIGIBILITY_CODE = 13130;
+var ErrorInterceptors = [
+  {
+    type: "response",
+    name: "user-eligibilitiy-change",
+    onError: (e) => {
+      const error = e;
+      if (error.response) {
+        const { response } = error;
+        if ((response == null ? void 0 : response.status) === 403 && (response == null ? void 0 : response.config).url.includes(process.env.BASE_URL) && (response == null ? void 0 : response.config.withCredentials)) {
+          if (response.data.errorCode === ERROR_ELIGIBILITY_CODE) {
+          }
+        }
+      }
+      return Promise.reject(error);
+    }
+  },
+  {
+    type: "response",
+    name: "too-many-request",
+    onError: (e) => {
+      const error = e;
+      if (error.response) {
+        const { response } = error;
+        if ((response == null ? void 0 : response.status) === 429) {
+        }
+      }
+      return Promise.reject(error);
+    }
+  }
+];
+
+// src/utils/ApiUtils.ts
+var import_axios3 = __toESM(require("axios"), 1);
+var ApiUtils = class {
+};
+ApiUtils.mergeAxiosConfigs = (config, overrides) => {
+  return {
+    ...config,
+    ...overrides,
+    headers: {
+      ...config == null ? void 0 : config.headers,
+      ...overrides == null ? void 0 : overrides.headers
+    }
+  };
+};
+ApiUtils.is4xxError = (error) => {
+  if (import_axios3.default.isAxiosError(error) && error.response) {
+    return error.response.status >= 400 && error.response.status <= 499;
+  }
+  return false;
+};
+
+// src/utils/UrlHelper.ts
+var _UrlHelper = class _UrlHelper {
+  static trimSlashFromStringEnd(pathString) {
+    let newString = pathString;
+    while (newString[newString.length - 1] === "/") {
+      newString = newString.slice(0, -1);
+    }
+    return newString;
+  }
+  static trimSlashFromStringStart(pathString) {
+    let newString = pathString;
+    while (newString[0] === "/") {
+      newString = newString.slice(1);
+    }
+    return newString;
+  }
+  static trimSlashFromStringEdges(pathString) {
+    return _UrlHelper.trimSlashFromStringStart(this.trimSlashFromStringEnd(pathString));
+  }
+  static combinePaths(...paths) {
+    const completePath = paths.join("/");
+    return completePath.replace(/\/{2,}/g, "/");
+  }
+  static combineURLPaths(urlString, ...paths) {
+    const url = new URL(urlString);
+    const { origin } = url;
+    const pathname = _UrlHelper.trimSlashFromStringEdges(_UrlHelper.combinePaths(url.pathname, ...paths));
+    return new URL(pathname, origin).toString();
+  }
+  static removeQueryParam(fullUrlString, param) {
+    const url = new URL(fullUrlString);
+    const params = url.searchParams;
+    const pathname = this.trimSlashFromStringEnd(url.pathname);
+    params.delete(param);
+    let newUrlString;
+    if (params.toString() === "") newUrlString = `${url.origin}${pathname}${url.hash}`;
+    else newUrlString = `${url.origin}${pathname}?${params.toString()}${url.hash}`;
+    return newUrlString;
+  }
+};
+_UrlHelper.isCompleteURLString = (urlString) => {
+  try {
+    const url = new URL(urlString);
+    return url.hostname !== "";
+  } catch (error) {
+  }
+  return false;
+};
+var UrlHelper = _UrlHelper;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccelByte,
+  AccelByteSDK,
+  ApiUtils,
+  AuthInterceptors,
+  BrowserHelper,
+  CodeGenUtil,
+  DecodeError,
+  DesktopChecker,
+  ERROR_CODE_LINK_DELETION_ACCOUNT,
+  ERROR_CODE_TOKEN_EXPIRED,
+  ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT,
+  ERROR_USER_BANNED,
+  ErrorInterceptors,
+  IamErrorCode,
+  Network,
+  RefreshSession,
+  SdkDevice,
+  UrlHelper,
+  Validate,
+  doRefreshSession,
+  refreshWithLock
+});
+//# sourceMappingURL=index.cjs.map