@foxford/sdk 6.2.1 → 7.0.0

package/api.cjs

@@ -0,0 +1,599 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  CamelizeRequestPlugin: () => CamelizeRequestPlugin,
+  CaptchaPlugin: () => CaptchaPlugin,
+  ReferrerRequestPlugin: () => ReferrerRequestPlugin,
+  apiBaseConfig: () => apiBaseConfig,
+  apiConfig: () => apiConfig,
+  defaultPlugins: () => defaultPlugins
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/constants.ts
+var CSRF_COOKIE_NAME = "_csrf_token";
+
+// src/api/config.ts
+var apiBaseConfig = {
+  headers: { "X-Requested-With": "XMLHttpRequest" },
+  withXSRFToken: true,
+  xsrfCookieName: CSRF_COOKIE_NAME,
+  xsrfHeaderName: "X-CSRF-Token"
+};
+var apiConfig = __spreadProps(__spreadValues({}, apiBaseConfig), {
+  withCredentials: true
+});
+
+// src/utils/camelize.ts
+var import_camelcase_keys_deep = __toESM(require("camelcase-keys-deep"), 1);
+var import_decamelize_keys_deep = __toESM(require("decamelize-keys-deep"), 1);
+var camelize = (obj) => (0, import_camelcase_keys_deep.default)(obj);
+
+// src/api/plugins/CamelizeRequestPlugin.ts
+var CamelizeRequestPlugin = class {
+  constructor() {
+    this.pluginType = "request";
+    this.pluginName = "camelizeRequestPlugin";
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  execute(config, instance) {
+    return new Promise((resolve) => {
+      const convert = typeof config.camelize === "boolean" ? config.camelize : true;
+      if (convert) {
+        const defaultTransform = instance.defaults.transformResponse;
+        const camelizeResponse = (data) => {
+          return camelize(data);
+        };
+        if (defaultTransform) {
+          config.transformResponse = Array.isArray(defaultTransform) ? [...defaultTransform, camelizeResponse] : [defaultTransform, camelizeResponse];
+        }
+      }
+      resolve(config);
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  isApplicable(config) {
+    return typeof config.camelize === "boolean" ? config.camelize : true;
+  }
+};
+
+// src/api/plugins/CaptchaPlugin.ts
+var import_services = require("@foxford/services");
+var CaptchaPlugin = class {
+  constructor(captchaConfig) {
+    this.pluginType = "responseFail";
+    this.pluginName = "captchaPlugin";
+    this.captchaConfig = captchaConfig;
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line complexity
+  execute(error) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      try {
+        const captchaConfig = typeof this.captchaConfig === "function" ? this.captchaConfig() : this.captchaConfig;
+        if (!captchaConfig) return error;
+        const { settings = {} } = (_b = (_a = error.response) == null ? void 0 : _a.data) != null ? _b : {};
+        const { provider } = settings;
+        const siteKey = settings.siteKey || settings.site_key || void 0;
+        if (!settings || !provider || !siteKey) return error;
+        this.captcha = new import_services.CaptchaService(__spreadProps(__spreadValues({}, captchaConfig), {
+          provider,
+          sitekey: siteKey
+        }));
+        const { config } = error;
+        const captchaAnswer = yield this.captcha.execute({
+          location: config.url,
+          method: config.method
+        });
+        if (captchaAnswer === null || captchaAnswer === void 0 || typeof (captchaAnswer == null ? void 0 : captchaAnswer.captcha_token) !== "string") {
+          return config;
+        }
+        const captchaPayload = {
+          verification: {
+            settings: {
+              token: captchaAnswer.captcha_token
+            },
+            type: "captcha"
+          }
+        };
+        if (config.method === "get") {
+          config.params = __spreadValues(__spreadValues({}, config.params), captchaPayload);
+        }
+        if (typeof config.data === "string") {
+          try {
+            let data = JSON.parse(config.data);
+            data = __spreadValues(__spreadValues({}, data), captchaPayload);
+            config.data = JSON.stringify(data);
+          } catch (err) {
+            console.error(err);
+          }
+        } else if (config.data instanceof FormData) {
+          const formData = config.data;
+          formData.append("verification[settings][token]", captchaPayload.verification.settings.token);
+          formData.append("verification[type]", captchaPayload.verification.type);
+          config.data = formData;
+        } else if (typeof config.data === "object") {
+          config.data = __spreadValues(__spreadValues({}, config.data), captchaPayload);
+        }
+        return config;
+      } catch (error2) {
+        return error2;
+      }
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  isApplicable(error) {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 449;
+  }
+};
+
+// src/api/plugins/DataLayerEventDispatcherPlugin.ts
+var DataLayerEventDispatcherPlugin = class {
+  constructor() {
+    this.pluginType = "responseSuccess";
+    this.pluginName = "dataLayerEventDispatcherPlugin";
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  execute(response) {
+    return new Promise((resolve) => {
+      try {
+        const rawResponse = JSON.parse(response.request.response);
+        if (Array.isArray(rawResponse["data_layer_events"])) {
+          if (!Array.isArray(window.dataLayer)) {
+            window.dataLayer = [];
+          }
+          window.dataLayer.push(...rawResponse["data_layer_events"]);
+        }
+      } catch (e) {
+      }
+      resolve(response);
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  isApplicable() {
+    return true;
+  }
+};
+
+// src/utils/pathToRegexp.ts
+function lexer(str) {
+  const tokens = [];
+  let i = 0;
+  while (i < str.length) {
+    const char = str[i];
+    if (char === "*" || char === "+" || char === "?") {
+      tokens.push({ index: i, type: "MODIFIER", value: str[i++] });
+      continue;
+    }
+    if (char === "\\") {
+      tokens.push({ index: i++, type: "ESCAPED_CHAR", value: str[i++] });
+      continue;
+    }
+    if (char === "{") {
+      tokens.push({ index: i, type: "OPEN", value: str[i++] });
+      continue;
+    }
+    if (char === "}") {
+      tokens.push({ index: i, type: "CLOSE", value: str[i++] });
+      continue;
+    }
+    if (char === ":") {
+      let name = "";
+      let j = i + 1;
+      while (j < str.length) {
+        const code = str.charCodeAt(j);
+        if (
+          // `0-9`
+          code >= 48 && code <= 57 || // `A-Z`
+          code >= 65 && code <= 90 || // `a-z`
+          code >= 97 && code <= 122 || // `_`
+          code === 95
+        ) {
+          name += str[j++];
+          continue;
+        }
+        break;
+      }
+      if (!name) throw new TypeError(`Missing parameter name at ${i}`);
+      tokens.push({ index: i, type: "NAME", value: name });
+      i = j;
+      continue;
+    }
+    if (char === "(") {
+      let count = 1;
+      let pattern = "";
+      let j = i + 1;
+      if (str[j] === "?") {
+        throw new TypeError(`Pattern cannot start with "?" at ${j}`);
+      }
+      while (j < str.length) {
+        if (str[j] === "\\") {
+          pattern += str[j++] + str[j++];
+          continue;
+        }
+        if (str[j] === ")") {
+          count--;
+          if (count === 0) {
+            j++;
+            break;
+          }
+        } else if (str[j] === "(") {
+          count++;
+          if (str[j + 1] !== "?") {
+            throw new TypeError(`Capturing groups are not allowed at ${j}`);
+          }
+        }
+        pattern += str[j++];
+      }
+      if (count) throw new TypeError(`Unbalanced pattern at ${i}`);
+      if (!pattern) throw new TypeError(`Missing pattern at ${i}`);
+      tokens.push({ index: i, type: "PATTERN", value: pattern });
+      i = j;
+      continue;
+    }
+    tokens.push({ index: i, type: "CHAR", value: str[i++] });
+  }
+  tokens.push({ index: i, type: "END", value: "" });
+  return tokens;
+}
+function parse(str, options = {}) {
+  const tokens = lexer(str);
+  const { prefixes = "./" } = options;
+  const defaultPattern = `[^${escapeString(options.delimiter || "/#?")}]+?`;
+  const result = [];
+  let key = 0;
+  let i = 0;
+  let path = "";
+  const tryConsume = (type) => {
+    var _a, _b;
+    if (i < tokens.length && ((_a = tokens[i]) == null ? void 0 : _a.type) === type) return (_b = tokens[i++]) == null ? void 0 : _b.value;
+    return void 0;
+  };
+  const mustConsume = (type) => {
+    var _a, _b;
+    const value = tryConsume(type);
+    if (value !== void 0) return value;
+    throw new TypeError(`Unexpected ${(_a = tokens[i]) == null ? void 0 : _a.type} at ${(_b = tokens[i]) == null ? void 0 : _b.index}, expected ${type}`);
+  };
+  const consumeText = () => {
+    let result2 = "";
+    let value;
+    while (value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+      result2 += value;
+    }
+    return result2;
+  };
+  while (i < tokens.length) {
+    const char = tryConsume("CHAR");
+    const name = tryConsume("NAME");
+    const pattern = tryConsume("PATTERN");
+    if (name || pattern) {
+      let prefix = char || "";
+      if (prefixes.indexOf(prefix) === -1) {
+        path += prefix;
+        prefix = "";
+      }
+      if (path) {
+        result.push(path);
+        path = "";
+      }
+      result.push({
+        modifier: tryConsume("MODIFIER") || "",
+        name: name || key++,
+        pattern: pattern || defaultPattern,
+        prefix,
+        suffix: ""
+      });
+      continue;
+    }
+    const value = char || tryConsume("ESCAPED_CHAR");
+    if (value) {
+      path += value;
+      continue;
+    }
+    if (path) {
+      result.push(path);
+      path = "";
+    }
+    const open = tryConsume("OPEN");
+    if (open) {
+      const prefix = consumeText();
+      const name2 = tryConsume("NAME") || "";
+      const pattern2 = tryConsume("PATTERN") || "";
+      const suffix = consumeText();
+      mustConsume("CLOSE");
+      result.push({
+        modifier: tryConsume("MODIFIER") || "",
+        name: name2 || (pattern2 ? key++ : ""),
+        pattern: name2 && !pattern2 ? defaultPattern : pattern2,
+        prefix,
+        suffix
+      });
+      continue;
+    }
+    mustConsume("END");
+  }
+  return result;
+}
+function escapeString(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+}
+function flags(options) {
+  return options && options.sensitive ? "" : "i";
+}
+function regexpToRegexp(path, keys) {
+  if (!keys) return path;
+  const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+  let index = 0;
+  let execResult = groupsRegex.exec(path.source);
+  while (execResult) {
+    keys.push({
+      modifier: "",
+      // Use parenthesized substring match if available, index otherwise
+      name: execResult[1] || index++,
+      pattern: "",
+      prefix: "",
+      suffix: ""
+    });
+    execResult = groupsRegex.exec(path.source);
+  }
+  return path;
+}
+function arrayToRegexp(paths, keys, options) {
+  const parts = paths.map((path) => pathToRegexp(path, keys, options).source);
+  return new RegExp(`(?:${parts.join("|")})`, flags(options));
+}
+function stringToRegexp(path, keys, options) {
+  return tokensToRegexp(parse(path, options), keys, options);
+}
+function tokensToRegexp(tokens, keys, options = {}) {
+  const {
+    strict = false,
+    start = true,
+    end = true,
+    encode = (x) => x,
+    delimiter = "/#?",
+    endsWith = ""
+  } = options;
+  const endsWithRe = `[${escapeString(endsWith)}]|$`;
+  const delimiterRe = `[${escapeString(delimiter)}]`;
+  let route = start ? "^" : "";
+  for (const token of tokens) {
+    if (typeof token === "string") {
+      route += escapeString(encode(token));
+    } else {
+      const prefix = escapeString(encode(token.prefix));
+      const suffix = escapeString(encode(token.suffix));
+      if (token.pattern) {
+        if (keys) keys.push(token);
+        if (prefix || suffix) {
+          if (token.modifier === "+" || token.modifier === "*") {
+            const mod = token.modifier === "*" ? "?" : "";
+            route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;
+          } else {
+            route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+          }
+        } else {
+          if (token.modifier === "+" || token.modifier === "*") {
+            route += `((?:${token.pattern})${token.modifier})`;
+          } else {
+            route += `(${token.pattern})${token.modifier}`;
+          }
+        }
+      } else {
+        route += `(?:${prefix}${suffix})${token.modifier}`;
+      }
+    }
+  }
+  if (end) {
+    if (!strict) route += `${delimiterRe}?`;
+    route += !options.endsWith ? "$" : `(?=${endsWithRe})`;
+  } else {
+    const endToken = tokens[tokens.length - 1];
+    const isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+    if (!strict) {
+      route += `(?:${delimiterRe}(?=${endsWithRe}))?`;
+    }
+    if (!isEndDelimited) {
+      route += `(?=${delimiterRe}|${endsWithRe})`;
+    }
+  }
+  return new RegExp(route, flags(options));
+}
+function pathToRegexp(path, keys, options) {
+  if (path instanceof RegExp) return regexpToRegexp(path, keys);
+  if (Array.isArray(path)) return arrayToRegexp(path, keys, options);
+  return stringToRegexp(path, keys, options);
+}
+
+// src/utils/matchPath.ts
+var cache = {};
+var cacheLimit = 1e4;
+var cacheCount = 0;
+function compilePath(path, options) {
+  const { end = false, strict = false, sensitive = false } = options;
+  const cacheKey = `${path}/${end.toString()}/${strict.toString()}/${sensitive.toString()}`;
+  const pathCache = cache[cacheKey] || (cache[cacheKey] = {});
+  if (pathCache[path]) return pathCache[path];
+  const keys = [];
+  const regexp = pathToRegexp(path, keys, options);
+  const result = { keys, regexp };
+  if (cacheCount < cacheLimit) {
+    pathCache[path] = result;
+    cacheCount += 1;
+  }
+  return result;
+}
+var matchPath = (pathname, options) => {
+  if (options === void 0) {
+    options = {};
+  }
+  if (typeof options === "string" || Array.isArray(options)) {
+    options = {
+      path: options
+    };
+  }
+  const _options = options, path = _options.path, _options$exact = _options.exact, exact = _options$exact === void 0 ? false : _options$exact, _options$strict = _options.strict, strict = _options$strict === void 0 ? false : _options$strict, _options$sensitive = _options.sensitive, sensitive = _options$sensitive === void 0 ? false : _options$sensitive;
+  const paths = [].concat(path);
+  return paths.reduce(function(matched, path2) {
+    if (!path2 && path2 !== "") return null;
+    if (matched) return matched;
+    const _compilePath = compilePath(path2, {
+      end: exact,
+      sensitive,
+      strict
+    }), regexp = _compilePath.regexp, keys = _compilePath.keys;
+    const match = regexp.exec(pathname);
+    if (!match) return null;
+    const url = match[0], values = match.slice(1);
+    const isExact = pathname === url;
+    if (exact && !isExact) return null;
+    return {
+      // the matched portion of the URL
+      isExact,
+      // whether or not we matched exactly
+      params: keys.reduce(function(memo, key, index) {
+        memo[key.name] = values[index];
+        return memo;
+      }, {}),
+      path: path2,
+      // the path used to match
+      url: path2 === "/" && url === "" ? "/" : url
+    };
+  }, null);
+};
+
+// src/api/plugins/ReferrerRequestPlugin.ts
+var REFERRER_PAYLOAD_NAME = "referrer";
+var REFERRER_ENDPOINTS = {
+  delete: [],
+  get: [],
+  patch: [],
+  post: ["/api/email_registration", "/api/phone_registration", "/api/auth/registration"],
+  put: []
+};
+var ReferrerRequestPlugin = class {
+  constructor() {
+    this.pluginType = "request";
+    this.pluginName = "referrerRequestPlugin";
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  execute(config) {
+    return new Promise((resolve) => {
+      const referrer = String(window.__fox_referrer__);
+      if (!referrer) {
+        resolve(config);
+      }
+      config.params = __spreadProps(__spreadValues({}, config.params), {
+        [REFERRER_PAYLOAD_NAME]: referrer
+      });
+      resolve(config);
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  getEndpoints() {
+    return REFERRER_ENDPOINTS;
+  }
+  isApplicable(config) {
+    var _a;
+    const { method, url: pathUrl = "" } = config;
+    const endpointMethod = method ? method : "post";
+    const endpoints = this.getEndpoints();
+    const referrerURLs = (_a = endpoints[endpointMethod]) != null ? _a : [];
+    return referrerURLs.some((url) => url === pathUrl || pathUrl && matchPath(pathUrl, { exact: true, path: url })) || config.withReferrer === true;
+  }
+};
+
+// src/api/index.ts
+var referrerRequestPlugin = new ReferrerRequestPlugin();
+var camelizeRequestPlugin = new CamelizeRequestPlugin();
+var dataLayerEventDispatcherPlugin = new DataLayerEventDispatcherPlugin();
+var defaultPlugins = [
+  camelizeRequestPlugin,
+  referrerRequestPlugin,
+  dataLayerEventDispatcherPlugin
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CamelizeRequestPlugin,
+  CaptchaPlugin,
+  ReferrerRequestPlugin,
+  apiBaseConfig,
+  apiConfig,
+  defaultPlugins
+});

package/api.d.cts

@@ -0,0 +1,68 @@
+import { RequestPlugin, ApiRequestConfigExtended, ApiInstance, ApiConfig, CaptchaConfig, ResponseFailPlugin, CaptchaService, ApiErrorExtended, RequestPluginInterface, ResponseSuccessPluginInterface } from '@foxford/services';
+import { FoxfordAntibotConfig } from './antibot.cjs';
+
+declare const apiBaseConfig: {
+    headers: {
+        'X-Requested-With': string;
+    };
+    withXSRFToken: boolean;
+    xsrfCookieName: string;
+    xsrfHeaderName: string;
+};
+declare const apiConfig: {
+    withCredentials: boolean;
+    headers: {
+        'X-Requested-With': string;
+    };
+    withXSRFToken: boolean;
+    xsrfCookieName: string;
+    xsrfHeaderName: string;
+};
+
+declare class CamelizeRequestPlugin implements RequestPlugin {
+    pluginType: "request";
+    pluginName: string;
+    execute(config: ApiRequestConfigExtended, instance: ApiInstance): Promise<ApiRequestConfigExtended>;
+    isApplicable(config: ApiRequestConfigExtended): boolean;
+}
+
+type WidgetsInitConfig = {
+    version?: 'latest' | string;
+    locale?: 'ru';
+};
+
+type FoxfordConfig = {
+    host?: string;
+    /** @deprecated */
+    widgetsVersion?: 'latest' | string;
+    antibot?: boolean;
+    antibotConfig?: FoxfordAntibotConfig;
+    api?: ApiConfig;
+    captchaConfig?: () => CaptchaConfig;
+    /** @deprecated Не используйте инициализацию виджетов через SDK */
+    widgetsConfig?: WidgetsInitConfig;
+};
+
+declare class CaptchaPlugin implements ResponseFailPlugin {
+    pluginType: "responseFail";
+    pluginName: string;
+    captchaConfig: FoxfordConfig['captchaConfig'];
+    captcha?: CaptchaService;
+    constructor(captchaConfig: FoxfordConfig['captchaConfig']);
+    execute(error: ApiErrorExtended): Promise<ApiErrorExtended | ApiRequestConfigExtended>;
+    isApplicable(error: ApiErrorExtended): boolean;
+}
+
+type ReferrerEndpointMethod = 'delete' | 'get' | 'patch' | 'post' | 'put';
+type ReferrerEndpointsType = Record<ReferrerEndpointMethod, string[]>;
+declare class ReferrerRequestPlugin implements RequestPlugin {
+    pluginType: "request";
+    pluginName: string;
+    execute(config: ApiRequestConfigExtended): Promise<ApiRequestConfigExtended>;
+    getEndpoints(): ReferrerEndpointsType;
+    isApplicable(config: ApiRequestConfigExtended): boolean;
+}
+
+declare const defaultPlugins: Array<RequestPluginInterface | ResponseSuccessPluginInterface>;
+
+export { CamelizeRequestPlugin, CaptchaPlugin, ReferrerRequestPlugin, apiBaseConfig, apiConfig, defaultPlugins };