@smartbills/sdk 0.0.1-alpha.1 → 0.0.2-alpha.11

package/dist/umd/index.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('uuid'), require('axios'), require('qs'), require('mime')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'uuid', 'axios', 'qs', 'mime'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Smartbills = {}, global.uuid, global.axios, global.qs, global.mime));
-})(this, (function (exports, uuid, axios, qs, mime) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('uuid'), require('axios'), require('mime')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'uuid', 'axios', 'mime'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Smartbills = {}, global.uuid, global.axios, global.mime));
+})(this, (function (exports, uuid, axios, mime) { 'use strict';
 
   function _typeof(o) {
     "@babel/helpers - typeof";
@@ -68,26 +68,35 @@
   class SBException extends Error {
     constructor(code, message, statusCode, errors) {
       super(message);
+      _defineProperty(this, "message", void 0);
       _defineProperty(this, "code", void 0);
       _defineProperty(this, "errors", []);
-      _defineProperty(this, "statusCode", void 0);
+      _defineProperty(this, "status", void 0);
       this.code = code;
       this.errors = errors;
-      this.statusCode = statusCode;
+      this.status = statusCode;
     }
   }
 
+  var version = "0.0.2-alpha.10";
+
+  const isBrowser = typeof window !== "undefined";
   class SBInstance {
     constructor(options = defaultAPIServiceOptions) {
       _defineProperty(this, "axios", void 0);
       _defineProperty(this, "logger", void 0);
-      this.logger = options.logger;
+      this.logger = options.logger ?? new SBLogger(options.debug);
       this.axios = axios.create({
-        baseURL: options.url
+        baseURL: options.url,
+        headers: !isBrowser ? {
+          "User-Agent": `Smartbills JS v${version}`
+        } : {}
       });
+      this.axios.defaults.headers["Accept-Language"] = options.locale;
       this.axios.defaults.headers["Session-Id"] = options?.sessionId;
       if (options.credentials) this.axios.interceptors.request.use(config => {
         config.headers["Authorization"] = "bearer " + options?.credentials?.accessToken;
+        this.logger.log("Request", config.method, config.url, config.data);
         return config;
       });
       const addRequestId = (data, headers) => {
@@ -96,7 +105,7 @@
       };
       this.axios.defaults.transformRequest = [addRequestId].concat(this.axios.defaults.transformRequest);
       this.axios.interceptors.response.use(response => {
-        this.logger.log("response", response.config.method, response.config.url, response.status, response?.data);
+        this.logger.log("response", response.config.method, response.config.url, response?.status, response?.data);
         return response;
       }, async error => {
         this.logger.log("REQUEST FAILED", error.config.headers["Request-Id"]);
@@ -124,7 +133,7 @@
         } catch (error) {
           if (axios.isAxiosError(error)) {
             const errors = error.response?.data ?? [];
-            throw new SBException(error.code, error.message, error.response.status, errors);
+            throw new SBException(error.code, error.message, error.response?.status, errors);
           } else {
             throw new SBException(error.code, error.message);
           }
@@ -133,6 +142,529 @@
     }
   }
 
+  const token = '%[a-f0-9]{2}';
+  const singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+  const multiMatcher = new RegExp('(' + token + ')+', 'gi');
+  function decodeComponents(components, split) {
+    try {
+      // Try to decode the entire string first
+      return [decodeURIComponent(components.join(''))];
+    } catch {
+      // Do nothing
+    }
+    if (components.length === 1) {
+      return components;
+    }
+    split = split || 1;
+
+    // Split the array in 2 parts
+    const left = components.slice(0, split);
+    const right = components.slice(split);
+    return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+  }
+  function decode$2(input) {
+    try {
+      return decodeURIComponent(input);
+    } catch {
+      let tokens = input.match(singleMatcher) || [];
+      for (let i = 1; i < tokens.length; i++) {
+        input = decodeComponents(tokens, i).join('');
+        tokens = input.match(singleMatcher) || [];
+      }
+      return input;
+    }
+  }
+  function customDecodeURIComponent(input) {
+    // Keep track of all the replacements and prefill the map with the `BOM`
+    const replaceMap = {
+      '%FE%FF': '\uFFFD\uFFFD',
+      '%FF%FE': '\uFFFD\uFFFD'
+    };
+    let match = multiMatcher.exec(input);
+    while (match) {
+      try {
+        // Decode as big chunks as possible
+        replaceMap[match[0]] = decodeURIComponent(match[0]);
+      } catch {
+        const result = decode$2(match[0]);
+        if (result !== match[0]) {
+          replaceMap[match[0]] = result;
+        }
+      }
+      match = multiMatcher.exec(input);
+    }
+
+    // Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+    replaceMap['%C2'] = '\uFFFD';
+    const entries = Object.keys(replaceMap);
+    for (const key of entries) {
+      // Replace all decoded components
+      input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+    }
+    return input;
+  }
+  function decodeUriComponent(encodedURI) {
+    if (typeof encodedURI !== 'string') {
+      throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+    }
+    try {
+      // Try the built in decoder first
+      return decodeURIComponent(encodedURI);
+    } catch {
+      // Fallback to a more advanced decoder
+      return customDecodeURIComponent(encodedURI);
+    }
+  }
+
+  function includeKeys(object, predicate) {
+    const result = {};
+    if (Array.isArray(predicate)) {
+      for (const key of predicate) {
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (descriptor?.enumerable) {
+          Object.defineProperty(result, key, descriptor);
+        }
+      }
+    } else {
+      // `Reflect.ownKeys()` is required to retrieve symbol properties
+      for (const key of Reflect.ownKeys(object)) {
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (descriptor.enumerable) {
+          const value = object[key];
+          if (predicate(key, value, object)) {
+            Object.defineProperty(result, key, descriptor);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  function splitOnFirst(string, separator) {
+    if (!(typeof string === 'string' && typeof separator === 'string')) {
+      throw new TypeError('Expected the arguments to be of type `string`');
+    }
+    if (string === '' || separator === '') {
+      return [];
+    }
+    const separatorIndex = string.indexOf(separator);
+    if (separatorIndex === -1) {
+      return [];
+    }
+    return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];
+  }
+
+  const isNullOrUndefined = value => value === null || value === undefined;
+
+  // eslint-disable-next-line unicorn/prefer-code-point
+  const strictUriEncode = string => encodeURIComponent(string).replaceAll(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+  const encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');
+  function encoderForArrayFormat(options) {
+    switch (options.arrayFormat) {
+      case 'index':
+        {
+          return key => (result, value) => {
+            const index = result.length;
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [...result, [encode(key, options), '[', index, ']'].join('')];
+            }
+            return [...result, [encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')];
+          };
+        }
+      case 'bracket':
+        {
+          return key => (result, value) => {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [...result, [encode(key, options), '[]'].join('')];
+            }
+            return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
+          };
+        }
+      case 'colon-list-separator':
+        {
+          return key => (result, value) => {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [...result, [encode(key, options), ':list='].join('')];
+            }
+            return [...result, [encode(key, options), ':list=', encode(value, options)].join('')];
+          };
+        }
+      case 'comma':
+      case 'separator':
+      case 'bracket-separator':
+        {
+          const keyValueSeparator = options.arrayFormat === 'bracket-separator' ? '[]=' : '=';
+          return key => (result, value) => {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+
+            // Translate null to an empty string so that it doesn't serialize as 'null'
+            value = value === null ? '' : value;
+            if (result.length === 0) {
+              return [[encode(key, options), keyValueSeparator, encode(value, options)].join('')];
+            }
+            return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+          };
+        }
+      default:
+        {
+          return key => (result, value) => {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [...result, encode(key, options)];
+            }
+            return [...result, [encode(key, options), '=', encode(value, options)].join('')];
+          };
+        }
+    }
+  }
+  function parserForArrayFormat(options) {
+    let result;
+    switch (options.arrayFormat) {
+      case 'index':
+        {
+          return (key, value, accumulator) => {
+            result = /\[(\d*)]$/.exec(key);
+            key = key.replace(/\[\d*]$/, '');
+            if (!result) {
+              accumulator[key] = value;
+              return;
+            }
+            if (accumulator[key] === undefined) {
+              accumulator[key] = {};
+            }
+            accumulator[key][result[1]] = value;
+          };
+        }
+      case 'bracket':
+        {
+          return (key, value, accumulator) => {
+            result = /(\[])$/.exec(key);
+            key = key.replace(/\[]$/, '');
+            if (!result) {
+              accumulator[key] = value;
+              return;
+            }
+            if (accumulator[key] === undefined) {
+              accumulator[key] = [value];
+              return;
+            }
+            accumulator[key] = [...accumulator[key], value];
+          };
+        }
+      case 'colon-list-separator':
+        {
+          return (key, value, accumulator) => {
+            result = /(:list)$/.exec(key);
+            key = key.replace(/:list$/, '');
+            if (!result) {
+              accumulator[key] = value;
+              return;
+            }
+            if (accumulator[key] === undefined) {
+              accumulator[key] = [value];
+              return;
+            }
+            accumulator[key] = [...accumulator[key], value];
+          };
+        }
+      case 'comma':
+      case 'separator':
+        {
+          return (key, value, accumulator) => {
+            const isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);
+            const isEncodedArray = typeof value === 'string' && !isArray && decode$1(value, options).includes(options.arrayFormatSeparator);
+            value = isEncodedArray ? decode$1(value, options) : value;
+            const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode$1(item, options)) : value === null ? value : decode$1(value, options);
+            accumulator[key] = newValue;
+          };
+        }
+      case 'bracket-separator':
+        {
+          return (key, value, accumulator) => {
+            const isArray = /(\[])$/.test(key);
+            key = key.replace(/\[]$/, '');
+            if (!isArray) {
+              accumulator[key] = value ? decode$1(value, options) : value;
+              return;
+            }
+            const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map(item => decode$1(item, options));
+            if (accumulator[key] === undefined) {
+              accumulator[key] = arrayValue;
+              return;
+            }
+            accumulator[key] = [...accumulator[key], ...arrayValue];
+          };
+        }
+      default:
+        {
+          return (key, value, accumulator) => {
+            if (accumulator[key] === undefined) {
+              accumulator[key] = value;
+              return;
+            }
+            accumulator[key] = [...[accumulator[key]].flat(), value];
+          };
+        }
+    }
+  }
+  function validateArrayFormatSeparator(value) {
+    if (typeof value !== 'string' || value.length !== 1) {
+      throw new TypeError('arrayFormatSeparator must be single character string');
+    }
+  }
+  function encode(value, options) {
+    if (options.encode) {
+      return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+    }
+    return value;
+  }
+  function decode$1(value, options) {
+    if (options.decode) {
+      return decodeUriComponent(value);
+    }
+    return value;
+  }
+  function keysSorter(input) {
+    if (Array.isArray(input)) {
+      return input.sort();
+    }
+    if (typeof input === 'object') {
+      return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map(key => input[key]);
+    }
+    return input;
+  }
+  function removeHash(input) {
+    const hashStart = input.indexOf('#');
+    if (hashStart !== -1) {
+      input = input.slice(0, hashStart);
+    }
+    return input;
+  }
+  function getHash(url) {
+    let hash = '';
+    const hashStart = url.indexOf('#');
+    if (hashStart !== -1) {
+      hash = url.slice(hashStart);
+    }
+    return hash;
+  }
+  function parseValue(value, options, type) {
+    if (type === 'string' && typeof value === 'string') {
+      return value;
+    }
+    if (typeof type === 'function' && typeof value === 'string') {
+      return type(value);
+    }
+    if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+      return value.toLowerCase() === 'true';
+    }
+    if (type === 'number' && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
+      return Number(value);
+    }
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
+      return Number(value);
+    }
+    return value;
+  }
+  function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf('?');
+    if (queryStart === -1) {
+      return '';
+    }
+    return input.slice(queryStart + 1);
+  }
+  function parse$6(query, options) {
+    options = {
+      decode: true,
+      sort: true,
+      arrayFormat: 'none',
+      arrayFormatSeparator: ',',
+      parseNumbers: false,
+      parseBooleans: false,
+      types: Object.create(null),
+      ...options
+    };
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const formatter = parserForArrayFormat(options);
+
+    // Create an object with no prototype
+    const returnValue = Object.create(null);
+    if (typeof query !== 'string') {
+      return returnValue;
+    }
+    query = query.trim().replace(/^[?#&]/, '');
+    if (!query) {
+      return returnValue;
+    }
+    for (const parameter of query.split('&')) {
+      if (parameter === '') {
+        continue;
+      }
+      const parameter_ = options.decode ? parameter.replaceAll('+', ' ') : parameter;
+      let [key, value] = splitOnFirst(parameter_, '=');
+      if (key === undefined) {
+        key = parameter_;
+      }
+
+      // Missing `=` should be `null`:
+      // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+      value = value === undefined ? null : ['comma', 'separator', 'bracket-separator'].includes(options.arrayFormat) ? value : decode$1(value, options);
+      formatter(decode$1(key, options), value, returnValue);
+    }
+    for (const [key, value] of Object.entries(returnValue)) {
+      if (typeof value === 'object' && value !== null && options.types[key] !== 'string') {
+        for (const [key2, value2] of Object.entries(value)) {
+          const type = options.types[key] ? options.types[key].replace('[]', '') : undefined;
+          value[key2] = parseValue(value2, options, type);
+        }
+      } else if (typeof value === 'object' && value !== null && options.types[key] === 'string') {
+        returnValue[key] = Object.values(value).join(options.arrayFormatSeparator);
+      } else {
+        returnValue[key] = parseValue(value, options, options.types[key]);
+      }
+    }
+    if (options.sort === false) {
+      return returnValue;
+    }
+
+    // TODO: Remove the use of `reduce`.
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return (options.sort === true ? Object.keys(returnValue).sort() : Object.keys(returnValue).sort(options.sort)).reduce((result, key) => {
+      const value = returnValue[key];
+      result[key] = Boolean(value) && typeof value === 'object' && !Array.isArray(value) ? keysSorter(value) : value;
+      return result;
+    }, Object.create(null));
+  }
+  function stringify$2(object, options) {
+    if (!object) {
+      return '';
+    }
+    options = {
+      encode: true,
+      strict: true,
+      arrayFormat: 'none',
+      arrayFormatSeparator: ',',
+      ...options
+    };
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const shouldFilter = key => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === '';
+    const formatter = encoderForArrayFormat(options);
+    const objectCopy = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (!shouldFilter(key)) {
+        objectCopy[key] = value;
+      }
+    }
+    const keys = Object.keys(objectCopy);
+    if (options.sort !== false) {
+      keys.sort(options.sort);
+    }
+    return keys.map(key => {
+      const value = object[key];
+      if (value === undefined) {
+        return '';
+      }
+      if (value === null) {
+        return encode(key, options);
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0 && options.arrayFormat === 'bracket-separator') {
+          return encode(key, options) + '[]';
+        }
+        return value.reduce(formatter(key), []).join('&');
+      }
+      return encode(key, options) + '=' + encode(value, options);
+    }).filter(x => x.length > 0).join('&');
+  }
+  function parseUrl(url, options) {
+    options = {
+      decode: true,
+      ...options
+    };
+    let [url_, hash] = splitOnFirst(url, '#');
+    if (url_ === undefined) {
+      url_ = url;
+    }
+    return {
+      url: url_?.split('?')?.[0] ?? '',
+      query: parse$6(extract(url), options),
+      ...(options && options.parseFragmentIdentifier && hash ? {
+        fragmentIdentifier: decode$1(hash, options)
+      } : {})
+    };
+  }
+  function stringifyUrl(object, options) {
+    options = {
+      encode: true,
+      strict: true,
+      [encodeFragmentIdentifier]: true,
+      ...options
+    };
+    const url = removeHash(object.url).split('?')[0] || '';
+    const queryFromUrl = extract(object.url);
+    const query = {
+      ...parse$6(queryFromUrl, {
+        sort: false
+      }),
+      ...object.query
+    };
+    let queryString = stringify$2(query, options);
+    queryString &&= `?${queryString}`;
+    let hash = getHash(object.url);
+    if (typeof object.fragmentIdentifier === 'string') {
+      const urlObjectForFragmentEncode = new URL(url);
+      urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
+      hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : `#${object.fragmentIdentifier}`;
+    }
+    return `${url}${queryString}${hash}`;
+  }
+  function pick(input, filter, options) {
+    options = {
+      parseFragmentIdentifier: true,
+      [encodeFragmentIdentifier]: false,
+      ...options
+    };
+    const {
+      url,
+      query,
+      fragmentIdentifier
+    } = parseUrl(input, options);
+    return stringifyUrl({
+      url,
+      query: includeKeys(query, filter),
+      fragmentIdentifier
+    }, options);
+  }
+  function exclude(input, filter, options) {
+    const exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);
+    return pick(input, exclusionFilter, options);
+  }
+
+  var queryString = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    exclude: exclude,
+    extract: extract,
+    parse: parse$6,
+    parseUrl: parseUrl,
+    pick: pick,
+    stringify: stringify$2,
+    stringifyUrl: stringifyUrl
+  });
+
   class SBService {
     constructor(options) {
       _defineProperty(this, "smartbills", void 0);
@@ -141,54 +673,61 @@
       this.smartbills = new SBInstance(options);
     }
     async getEntities(path, request, options, config = {}) {
-      this.prepareRequest(options);
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios.get(path, {
         params: request,
-        paramsSerializer: params => qs.stringify(params, {
-          arrayFormat: 'indices'
+        paramsSerializer: params => queryString.stringify(params, {
+          arrayFormat: "index"
         }),
         ...config
       });
       return response.data;
     }
     async getEntityById(path, options, config = {}) {
-      this.prepareRequest(options);
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios.get(path, config);
       return response.data;
     }
     async createEntity(path, request, options, config = {}) {
-      this.prepareRequest(options);
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios.post(path, request, config);
       return response.data;
     }
     async updateEntity(path, request, options, config = {}) {
-      this.prepareRequest(options);
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios.put(path, request, config);
       return response.data;
     }
     async deleteEntity(path, options, config = {}) {
-      this.prepareRequest(options);
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios.delete(path, config);
       return response.data;
     }
     async listEntities(path, request, options, config = {}) {
-      this.prepareRequest(options);
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios.get(path, {
         params: request,
         ...config
       });
       return response.data;
     }
-    async execute(options, config = {}) {
-      this.prepareRequest(options);
+    async execute(options, config) {
+      config = this.prepareRequest(options, config);
       const response = await this.smartbills.axios(config);
       return response.data;
     }
-    prepareRequest(options) {
+    prepareRequest(options, config = {}) {
+      const headers = {};
       const merchantId = options?.merchantId ?? this.options?.merchantId;
+      const locale = options?.locale ?? this.options.locale;
       if (merchantId) {
-        this.smartbills.axios.defaults.headers.common["x-tenant-id"] = merchantId;
+        headers["x-tenant-id"] = merchantId;
+      }
+      if (locale) {
+        headers["Accept-Language"] = locale;
       }
+      config.headers = headers;
+      return config;
     }
   }
 
@@ -204,21 +743,6 @@
     }
   }
 
-  class ApplicationService extends SBService {
-    async get(request, options, config) {
-      return await super.getEntities("/v1/applications", request, options, config);
-    }
-    async getById(id, options, config) {
-      return await super.getEntityById(`/v1/applications/${id}`, options, config);
-    }
-    async getBySlug(slug, options, config) {
-      return await super.getEntityById(`/v1/applications/${slug}`, options, config);
-    }
-    async delete(id, options, config) {
-      return await super.deleteEntity(`/v1/applications/${id}`, options, config);
-    }
-  }
-
   class BankAccountService extends SBService {
     constructor(options = defaultAPIServiceOptions) {
       super(options);
@@ -423,7 +947,7 @@
         name,
         uri
       }) => {
-        formData.append('files', {
+        formData.append("files", {
           name: name,
           uri: uri,
           type: mime.getType(uri)
@@ -472,21 +996,6 @@
     }
   }
 
-  class IntegrationService extends SBService {
-    async list(request, options, config) {
-      return await super.listEntities("/v1/integrations", request, options, config);
-    }
-    async getById(id, options, config) {
-      return await super.getEntityById(`/v1/integrations/${id}`, options, config);
-    }
-    async getBySlug(slug, options, config) {
-      return await super.getEntityById(`/v1/integrations/${slug}`, options, config);
-    }
-    async delete(id, options, config) {
-      return await super.deleteEntity(`/v1/integrations/${id}`, options, config);
-    }
-  }
-
   class LocationService extends SBService {
     async create(request, options, config) {
       return await super.createEntity(`/v1/locations`, request, options, config);
@@ -5599,6 +6108,12 @@
     SBOrganizationRole["Employee"] = "employee";
   })(exports.SBOrganizationRole || (exports.SBOrganizationRole = {}));
 
+  exports.SBPaymentMethodCardFingerprintProvider = void 0;
+  (function (SBPaymentMethodCardFingerprintProvider) {
+    SBPaymentMethodCardFingerprintProvider[SBPaymentMethodCardFingerprintProvider["Stripe"] = 0] = "Stripe";
+    SBPaymentMethodCardFingerprintProvider[SBPaymentMethodCardFingerprintProvider["Square"] = 1] = "Square";
+  })(exports.SBPaymentMethodCardFingerprintProvider || (exports.SBPaymentMethodCardFingerprintProvider = {}));
+
   const SBReceiptType = {
     bankTransaction: 0,
     OCR: 1,
@@ -5622,6 +6137,78 @@
     SBTransactionType[SBTransactionType["OFFICIAL_SMARTBILLS_RECEIPT"] = 3] = "OFFICIAL_SMARTBILLS_RECEIPT";
   })(exports.SBTransactionType || (exports.SBTransactionType = {}));
 
+  exports.SBReceiptPaymentType = void 0;
+  (function (SBReceiptPaymentType) {
+    SBReceiptPaymentType["Card"] = "Card";
+    SBReceiptPaymentType["Cash"] = "Cash";
+    SBReceiptPaymentType["BankAccount"] = "BankAccount";
+    SBReceiptPaymentType["External"] = "External";
+    SBReceiptPaymentType["Credits"] = "Credits";
+    SBReceiptPaymentType["GiftCard"] = "GiftCard";
+  })(exports.SBReceiptPaymentType || (exports.SBReceiptPaymentType = {}));
+
+  exports.SBReceiptPaymentRiskLevel = void 0;
+  (function (SBReceiptPaymentRiskLevel) {
+    SBReceiptPaymentRiskLevel[SBReceiptPaymentRiskLevel["Normal"] = 0] = "Normal";
+    SBReceiptPaymentRiskLevel[SBReceiptPaymentRiskLevel["Elevated"] = 1] = "Elevated";
+    SBReceiptPaymentRiskLevel[SBReceiptPaymentRiskLevel["High"] = 2] = "High";
+  })(exports.SBReceiptPaymentRiskLevel || (exports.SBReceiptPaymentRiskLevel = {}));
+
+  exports.SBReceiptPaymentStatus = void 0;
+  (function (SBReceiptPaymentStatus) {
+    SBReceiptPaymentStatus[SBReceiptPaymentStatus["Approved"] = 0] = "Approved";
+    SBReceiptPaymentStatus[SBReceiptPaymentStatus["Pending"] = 1] = "Pending";
+    SBReceiptPaymentStatus[SBReceiptPaymentStatus["Completed"] = 2] = "Completed";
+    SBReceiptPaymentStatus[SBReceiptPaymentStatus["Cancelled"] = 3] = "Cancelled";
+    SBReceiptPaymentStatus[SBReceiptPaymentStatus["Failed"] = 4] = "Failed";
+  })(exports.SBReceiptPaymentStatus || (exports.SBReceiptPaymentStatus = {}));
+
+  exports.SBReceiptPaymentCardAvsResult = void 0;
+  (function (SBReceiptPaymentCardAvsResult) {
+    SBReceiptPaymentCardAvsResult["PostalCodeAddressMatched"] = "A";
+    SBReceiptPaymentCardAvsResult["PostalCodeMatchedAddressNotChecked"] = "B";
+    SBReceiptPaymentCardAvsResult["PostalCodeMatchedAddressNotMatched"] = "C";
+    SBReceiptPaymentCardAvsResult["AddressMatchedPostalCodeNotChecked"] = "D";
+    SBReceiptPaymentCardAvsResult["PostalCodeAddressNotChecked"] = "E";
+    SBReceiptPaymentCardAvsResult["AddressMatchedPostalCodeNotMatched"] = "F";
+    SBReceiptPaymentCardAvsResult["PostalCodeNotCheckedAddressNotMatched"] = "G";
+    SBReceiptPaymentCardAvsResult["PostalCodeAddressNotSupplied"] = "H";
+    SBReceiptPaymentCardAvsResult["AddressNotCheckedPostalCodeNotMatched"] = "I";
+    SBReceiptPaymentCardAvsResult["PostalCodeAddressNotMatched"] = "J";
+  })(exports.SBReceiptPaymentCardAvsResult || (exports.SBReceiptPaymentCardAvsResult = {}));
+
+  exports.SBReceiptPaymentCardCvvResult = void 0;
+  (function (SBReceiptPaymentCardCvvResult) {
+    SBReceiptPaymentCardCvvResult["CVVMatched"] = "M";
+    SBReceiptPaymentCardCvvResult["CVVNotMatched"] = "N";
+    SBReceiptPaymentCardCvvResult["CVVNotChecked"] = "P";
+  })(exports.SBReceiptPaymentCardCvvResult || (exports.SBReceiptPaymentCardCvvResult = {}));
+
+  exports.SBReceiptPaymentCardEntryMethod = void 0;
+  (function (SBReceiptPaymentCardEntryMethod) {
+    SBReceiptPaymentCardEntryMethod[SBReceiptPaymentCardEntryMethod["Manual"] = 0] = "Manual";
+    SBReceiptPaymentCardEntryMethod[SBReceiptPaymentCardEntryMethod["Swiped"] = 1] = "Swiped";
+    SBReceiptPaymentCardEntryMethod[SBReceiptPaymentCardEntryMethod["EMV"] = 2] = "EMV";
+    SBReceiptPaymentCardEntryMethod[SBReceiptPaymentCardEntryMethod["OnFile"] = 3] = "OnFile";
+    SBReceiptPaymentCardEntryMethod[SBReceiptPaymentCardEntryMethod["Contactless"] = 4] = "Contactless";
+  })(exports.SBReceiptPaymentCardEntryMethod || (exports.SBReceiptPaymentCardEntryMethod = {}));
+
+  exports.SBReceiptPaymentExternalType = void 0;
+  (function (SBReceiptPaymentExternalType) {
+    SBReceiptPaymentExternalType["Check"] = "Check";
+    SBReceiptPaymentExternalType["BankTransfer"] = "BankTransfer";
+    SBReceiptPaymentExternalType["OtherGiftCard"] = "OtherGiftCard";
+    SBReceiptPaymentExternalType["Crypto"] = "Crypto";
+    SBReceiptPaymentExternalType["SquareCash"] = "SquareCash";
+    SBReceiptPaymentExternalType["Social"] = "Social";
+    SBReceiptPaymentExternalType["External"] = "External";
+    SBReceiptPaymentExternalType["EMoney"] = "EMoney";
+    SBReceiptPaymentExternalType["Card"] = "Card";
+    SBReceiptPaymentExternalType["StoredBalance"] = "StoredBalance";
+    SBReceiptPaymentExternalType["FoodVoucher"] = "FoodVoucher";
+    SBReceiptPaymentExternalType["Other"] = "Other";
+  })(exports.SBReceiptPaymentExternalType || (exports.SBReceiptPaymentExternalType = {}));
+
   var entities = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get SBBankStateEnum () { return exports.SBBankStateEnum; },
@@ -5630,6 +6217,14 @@
     get SBFeeType () { return exports.SBFeeType; },
     get SBGenderEnum () { return exports.SBGenderEnum; },
     get SBOrganizationRole () { return exports.SBOrganizationRole; },
+    get SBPaymentMethodCardFingerprintProvider () { return exports.SBPaymentMethodCardFingerprintProvider; },
+    get SBReceiptPaymentCardAvsResult () { return exports.SBReceiptPaymentCardAvsResult; },
+    get SBReceiptPaymentCardCvvResult () { return exports.SBReceiptPaymentCardCvvResult; },
+    get SBReceiptPaymentCardEntryMethod () { return exports.SBReceiptPaymentCardEntryMethod; },
+    get SBReceiptPaymentExternalType () { return exports.SBReceiptPaymentExternalType; },
+    get SBReceiptPaymentRiskLevel () { return exports.SBReceiptPaymentRiskLevel; },
+    get SBReceiptPaymentStatus () { return exports.SBReceiptPaymentStatus; },
+    get SBReceiptPaymentType () { return exports.SBReceiptPaymentType; },
     get SBReceiptSource () { return exports.SBReceiptSource; },
     SBReceiptType: SBReceiptType,
     get SBTransactionType () { return exports.SBTransactionType; }
@@ -10717,11 +11312,11 @@
       _defineProperty(this, "session_state", void 0);
       _defineProperty(this, "scope", void 0);
       const parsedHTML = _default(response);
-      this.redirectUrl = parsedHTML.querySelector('form').attributes.action;
-      const inputs = parsedHTML.querySelectorAll('input');
-      this.code = this.findInputValue(inputs, 'code');
-      this.session_state = this.findInputValue(inputs, 'session_state');
-      this.scope = this.findInputValue(inputs, 'scope');
+      this.redirectUrl = parsedHTML.querySelector("form").attributes.action;
+      const inputs = parsedHTML.querySelectorAll("input");
+      this.code = this.findInputValue(inputs, "code");
+      this.session_state = this.findInputValue(inputs, "session_state");
+      this.scope = this.findInputValue(inputs, "scope");
     }
     findInputValue(inputs, name) {
       return inputs.find(x => x.attributes.name == name).attributes.value;
@@ -10740,7 +11335,7 @@
           ...request
         },
         headers: {
-          'content-type': 'application/x-www-form-urlencoded'
+          "content-type": "application/x-www-form-urlencoded"
         }
       });
       return new AuthorizationCodeResponse(response);
@@ -10748,16 +11343,16 @@
     async getToken(request) {
       return await super.execute(null, {
         url: "/connect/token",
-        method: 'POST',
-        data: qs.stringify(request),
+        method: "POST",
+        data: queryString.stringify(request),
         withCredentials: true
       });
     }
     async refreshToken(loginRequest) {
       return await super.execute(null, {
         url: "/connect/token",
-        method: 'POST',
-        data: qs.stringify(loginRequest)
+        method: "POST",
+        data: queryString.stringify(loginRequest)
       });
     }
   }
@@ -10987,7 +11582,7 @@
         name,
         uri
       }) => {
-        formData.append('files', {
+        formData.append("files", {
           name: name,
           uri: uri,
           type: mime.getType(uri)
@@ -11070,7 +11665,8 @@
     },
     debug: false,
     logger: new SBLogger(false),
-    sessionId: uuid.v4()
+    sessionId: uuid.v4(),
+    locale: "en"
   };
   class SBClient {
     /**
@@ -11080,7 +11676,6 @@
     constructor(options = defaultAPIServiceOptions) {
       _defineProperty(this, "logger", void 0);
       _defineProperty(this, "options", void 0);
-      _defineProperty(this, "applications", void 0);
       _defineProperty(this, "user", void 0);
       _defineProperty(this, "logs", void 0);
       _defineProperty(this, "banks", void 0);
@@ -11093,7 +11688,6 @@
       _defineProperty(this, "customers", void 0);
       _defineProperty(this, "documents", void 0);
       _defineProperty(this, "domains", void 0);
-      _defineProperty(this, "integrations", void 0);
       _defineProperty(this, "explore", void 0);
       _defineProperty(this, "fees", void 0);
       _defineProperty(this, "reviews", void 0);
@@ -11137,17 +11731,15 @@
       this.options.credentials = credentials;
       this.configureServices();
     }
+    setLocale(locale) {
+      this.options.locale = locale;
+    }
     configureServices() {
       this.oauth = new OAuthService({
         ...this.options,
         logger: this.logger,
         url: this.options?.endpoints?.auth
       });
-      this.applications = new ApplicationService({
-        ...this.options,
-        logger: this.logger,
-        url: this.options?.endpoints?.api
-      });
       this.cards = new CardService({
         ...this.options,
         logger: this.logger,
@@ -11204,11 +11796,6 @@
         logger: this.logger,
         url: this.options?.endpoints?.api
       });
-      this.integrations = new IntegrationService({
-        ...this.options,
-        logger: this.logger,
-        url: this.options?.endpoints?.api
-      });
       this.locations = new LocationService({
         ...this.options,
         logger: this.logger,
@@ -11361,6 +11948,54 @@
     }
   }
 
+  exports.SBPermission = void 0;
+  (function (SBPermission) {
+    SBPermission["CUSTOMERS_READ"] = "customers:read";
+    SBPermission["CUSTOMERS_CREATE"] = "customers:create";
+    SBPermission["CUSTOMERS_DELETE"] = "customers:delete";
+    SBPermission["CUSTOMERS_UPDATE"] = "customers:update";
+    SBPermission["EMPLOYEES_READ"] = "employees:read";
+    SBPermission["EMPLOYEES_CREATE"] = "employees:create";
+    SBPermission["EMPLOYEES_DELETE"] = "employees:delete";
+    SBPermission["EMPLOYEES_UPDATE"] = "employees:update";
+    SBPermission["LOCATIONS_READ"] = "locations:read";
+    SBPermission["LOCATIONS_CREATE"] = "locations:create";
+    SBPermission["LOCATIONS_DELETE"] = "locations:delete";
+    SBPermission["LOCATIONS_UPDATE"] = "locations:update";
+    SBPermission["PRODUCTS_READ"] = "products:read";
+    SBPermission["PRODUCTS_CREATE"] = "products:create";
+    SBPermission["PRODUCTS_DELETE"] = "products:delete";
+    SBPermission["PRODUCTS_UPDATE"] = "products:update";
+    SBPermission["PAYMENTS_READ"] = "payments:read";
+    SBPermission["PAYMENTS_CREATE"] = "payments:create";
+    SBPermission["PAYMENTS_DELETE"] = "payments:delete";
+    SBPermission["PAYMENTS_UPDATE"] = "payments:update";
+    SBPermission["MERCHANTS_READ"] = "merchantsread";
+    SBPermission["MERCHANTS_CREATE"] = "merchants:create";
+    SBPermission["MERCHANTS_DELETE"] = "merchants:delete";
+    SBPermission["MERCHANTS_UPDATE"] = "merchants:update";
+    SBPermission["RECEIPTS_READ"] = "receipts:read";
+    SBPermission["RECEIPTS_CREATE"] = "receipts:create";
+    SBPermission["RECEIPTS_DELETE"] = "receipts:delete";
+    SBPermission["RECEIPTS_UPDATE"] = "receipts:update";
+    SBPermission["REVIEWS_READ"] = "reviews:read";
+    SBPermission["REVIEWS_CREATE"] = "reviews:create";
+    SBPermission["REVIEWS_DELETE"] = "reviews:delete";
+    SBPermission["REVIEWS_UPDATE"] = "reviews:update";
+    SBPermission["PROMO_CODES_READ"] = "promo_codes:read";
+    SBPermission["PROMO_CODES_CREATE"] = "promo_codes:create";
+    SBPermission["PROMO_CODES_DELETE"] = "promo_codes:delete";
+    SBPermission["PROMO_CODES_UPDATE"] = "promo_codes:update";
+    SBPermission["FEES_READ"] = "fees:read";
+    SBPermission["FEES_CREATE"] = "fees:create";
+    SBPermission["FEES_DELETE"] = "fees:delete";
+    SBPermission["FEES_UPDATE"] = "fees:update";
+    SBPermission["TAXES_READ"] = "taxes:read";
+    SBPermission["TAXES_CREATE"] = "taxes:create";
+    SBPermission["TAXES_DELETE"] = "taxes:delete";
+    SBPermission["TAXES_UPDATE"] = "taxes:update";
+  })(exports.SBPermission || (exports.SBPermission = {}));
+
   exports.LOGIN_ERRORS = void 0;
   (function (LOGIN_ERRORS) {
     LOGIN_ERRORS["InvalidLoginErrors"] = "invalid_return_url";
@@ -11421,7 +12056,6 @@
 
   exports.AccessTokenResponse = AccessTokenResponse;
   exports.ApiLogService = ApiLogService;
-  exports.ApplicationService = ApplicationService;
   exports.AuthorizationCodeResponse = AuthorizationCodeResponse;
   exports.BankAccountService = BankAccountService;
   exports.BankInstitutionService = BankInstitutionService;
@@ -11436,7 +12070,6 @@
   exports.ExploreService = ExploreService;
   exports.FeeService = FeeService;
   exports.FriendService = FriendService;
-  exports.IntegrationService = IntegrationService;
   exports.LocationService = LocationService;
   exports.MerchantService = MerchantService;
   exports.OAuthService = OAuthService;
@@ -11456,6 +12089,7 @@
   exports.SBErrorResponse = SBErrorResponse;
   exports.SBException = SBException;
   exports.SBInstance = SBInstance;
+  exports.SBLogger = SBLogger;
   exports.SBReceiptType = SBReceiptType;
   exports.SBService = SBService;
   exports.SettlementService = SettlementService;