@bitrix24/b24jssdk 0.1.7 → 0.2.1

package/dist/umd/index.js

@@ -1,5 +1,5 @@
 /**
- * @version @bitrix24/b24jssdk v0.1.7
+ * @version @bitrix24/b24jssdk v0.2.1
  * @copyright (c) 2025 Bitrix24
  * @licence MIT
  * @links https://github.com/bitrix24/b24jssdk - GitHub
@@ -491,6 +491,24 @@
 	}
 	const Type = new TypeManager();
 
+	function pick$1(data, keys) {
+	  const result = {};
+	  for (const key of keys) {
+	    result[key] = data[key];
+	  }
+	  return result;
+	}
+	function omit(data, keys) {
+	  const result = { ...data };
+	  for (const key of keys) {
+	    delete result[key];
+	  }
+	  return result;
+	}
+	function isArrayOfArray(item) {
+	  return Array.isArray(item[0]);
+	}
+
 	// these aren't really private, but nor are they really useful to document
 
 	/**
@@ -885,12 +903,13 @@
 	  }
 	}
 
-	let dtfCache = {};
-	function makeDTF(zone) {
-	  if (!dtfCache[zone]) {
-	    dtfCache[zone] = new Intl.DateTimeFormat("en-US", {
+	const dtfCache = new Map();
+	function makeDTF(zoneName) {
+	  let dtf = dtfCache.get(zoneName);
+	  if (dtf === undefined) {
+	    dtf = new Intl.DateTimeFormat("en-US", {
 	      hour12: false,
-	      timeZone: zone,
+	      timeZone: zoneName,
 	      year: "numeric",
 	      month: "2-digit",
 	      day: "2-digit",
@@ -899,8 +918,9 @@
 	      second: "2-digit",
 	      era: "short",
 	    });
+	    dtfCache.set(zoneName, dtf);
 	  }
-	  return dtfCache[zone];
+	  return dtf;
 	}
 
 	const typeToPos = {
@@ -936,7 +956,7 @@
 	  return filled;
 	}
 
-	let ianaZoneCache = {};
+	const ianaZoneCache = new Map();
 	/**
 	 * A zone identified by an IANA identifier, like America/New_York
 	 * @implements {Zone}
@@ -947,10 +967,11 @@
 	   * @return {IANAZone}
 	   */
 	  static create(name) {
-	    if (!ianaZoneCache[name]) {
-	      ianaZoneCache[name] = new IANAZone(name);
+	    let zone = ianaZoneCache.get(name);
+	    if (zone === undefined) {
+	      ianaZoneCache.set(name, (zone = new IANAZone(name)));
 	    }
-	    return ianaZoneCache[name];
+	    return zone;
 	  }
 
 	  /**
@@ -958,8 +979,8 @@
 	   * @return {void}
 	   */
 	  static resetCache() {
-	    ianaZoneCache = {};
-	    dtfCache = {};
+	    ianaZoneCache.clear();
+	    dtfCache.clear();
 	  }
 
 	  /**
@@ -1062,6 +1083,7 @@
 	   * @return {number}
 	   */
 	  offset(ts) {
+	    if (!this.valid) return NaN;
 	    const date = new Date(ts);
 
 	    if (isNaN(date)) return NaN;
@@ -1127,36 +1149,36 @@
 	  return dtf;
 	}
 
-	let intlDTCache = {};
+	const intlDTCache = new Map();
 	function getCachedDTF(locString, opts = {}) {
 	  const key = JSON.stringify([locString, opts]);
-	  let dtf = intlDTCache[key];
-	  if (!dtf) {
+	  let dtf = intlDTCache.get(key);
+	  if (dtf === undefined) {
 	    dtf = new Intl.DateTimeFormat(locString, opts);
-	    intlDTCache[key] = dtf;
+	    intlDTCache.set(key, dtf);
 	  }
 	  return dtf;
 	}
 
-	let intlNumCache = {};
+	const intlNumCache = new Map();
 	function getCachedINF(locString, opts = {}) {
 	  const key = JSON.stringify([locString, opts]);
-	  let inf = intlNumCache[key];
-	  if (!inf) {
+	  let inf = intlNumCache.get(key);
+	  if (inf === undefined) {
 	    inf = new Intl.NumberFormat(locString, opts);
-	    intlNumCache[key] = inf;
+	    intlNumCache.set(key, inf);
 	  }
 	  return inf;
 	}
 
-	let intlRelCache = {};
+	const intlRelCache = new Map();
 	function getCachedRTF(locString, opts = {}) {
 	  const { base, ...cacheKeyOpts } = opts; // exclude `base` from the options
 	  const key = JSON.stringify([locString, cacheKeyOpts]);
-	  let inf = intlRelCache[key];
-	  if (!inf) {
+	  let inf = intlRelCache.get(key);
+	  if (inf === undefined) {
 	    inf = new Intl.RelativeTimeFormat(locString, opts);
-	    intlRelCache[key] = inf;
+	    intlRelCache.set(key, inf);
 	  }
 	  return inf;
 	}
@@ -1171,14 +1193,28 @@
 	  }
 	}
 
-	let weekInfoCache = {};
+	const intlResolvedOptionsCache = new Map();
+	function getCachedIntResolvedOptions(locString) {
+	  let opts = intlResolvedOptionsCache.get(locString);
+	  if (opts === undefined) {
+	    opts = new Intl.DateTimeFormat(locString).resolvedOptions();
+	    intlResolvedOptionsCache.set(locString, opts);
+	  }
+	  return opts;
+	}
+
+	const weekInfoCache = new Map();
 	function getCachedWeekInfo(locString) {
-	  let data = weekInfoCache[locString];
+	  let data = weekInfoCache.get(locString);
 	  if (!data) {
 	    const locale = new Intl.Locale(locString);
 	    // browsers currently implement this as a property, but spec says it should be a getter function
 	    data = "getWeekInfo" in locale ? locale.getWeekInfo() : locale.weekInfo;
-	    weekInfoCache[locString] = data;
+	    // minimalDays was removed from WeekInfo: https://github.com/tc39/proposal-intl-locale-info/issues/86
+	    if (!("minimalDays" in data)) {
+	      data = { ...fallbackWeekSettings, ...data };
+	    }
+	    weekInfoCache.set(locString, data);
 	  }
 	  return data;
 	}
@@ -1277,7 +1313,7 @@
 	      loc.numberingSystem === "latn" ||
 	      !loc.locale ||
 	      loc.locale.startsWith("en") ||
-	      new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn"
+	      getCachedIntResolvedOptions(loc.locale).numberingSystem === "latn"
 	    );
 	  }
 	}
@@ -1436,7 +1472,6 @@
 	/**
 	 * @private
 	 */
-
 	class Locale {
 	  static fromOpts(opts) {
 	    return Locale.create(
@@ -1460,9 +1495,11 @@
 
 	  static resetCache() {
 	    sysLocaleCache = null;
-	    intlDTCache = {};
-	    intlNumCache = {};
-	    intlRelCache = {};
+	    intlDTCache.clear();
+	    intlNumCache.clear();
+	    intlRelCache.clear();
+	    intlResolvedOptionsCache.clear();
+	    weekInfoCache.clear();
 	  }
 
 	  static fromObject({ locale, numberingSystem, outputCalendar, weekSettings } = {}) {
@@ -1616,7 +1653,7 @@
 	    return (
 	      this.locale === "en" ||
 	      this.locale.toLowerCase() === "en-us" ||
-	      new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us")
+	      getCachedIntResolvedOptions(this.intl).locale.startsWith("en-us")
 	    );
 	  }
 
@@ -1955,22 +1992,26 @@
 	}
 
 	// cache of {numberingSystem: {append: regex}}
-	let digitRegexCache = {};
+	const digitRegexCache = new Map();
 	function resetDigitRegexCache() {
-	  digitRegexCache = {};
+	  digitRegexCache.clear();
 	}
 
 	function digitRegex({ numberingSystem }, append = "") {
 	  const ns = numberingSystem || "latn";
 
-	  if (!digitRegexCache[ns]) {
-	    digitRegexCache[ns] = {};
+	  let appendCache = digitRegexCache.get(ns);
+	  if (appendCache === undefined) {
+	    appendCache = new Map();
+	    digitRegexCache.set(ns, appendCache);
 	  }
-	  if (!digitRegexCache[ns][append]) {
-	    digitRegexCache[ns][append] = new RegExp(`${numberingSystems[ns]}${append}`);
+	  let regex = appendCache.get(append);
+	  if (regex === undefined) {
+	    regex = new RegExp(`${numberingSystems[ns]}${append}`);
+	    appendCache.set(append, regex);
 	  }
 
-	  return digitRegexCache[ns][append];
+	  return regex;
 	}
 
 	let now = () => Date.now(),
@@ -4722,6 +4763,14 @@
 	    return this.isValid ? this.e : null;
 	  }
 
+	  /**
+	   * Returns the last DateTime included in the interval (since end is not part of the interval)
+	   * @type {DateTime}
+	   */
+	  get lastDateTime() {
+	    return this.isValid ? (this.e ? this.e.minus(1) : null) : null;
+	  }
+
 	  /**
 	   * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
 	   * @type {boolean}
@@ -4986,8 +5035,11 @@
 	  }
 
 	  /**
-	   * Merge an array of Intervals into a equivalent minimal set of Intervals.
+	   * Merge an array of Intervals into an equivalent minimal set of Intervals.
 	   * Combines overlapping and adjacent Intervals.
+	   * The resulting array will contain the Intervals in ascending order, that is, starting with the earliest Interval
+	   * and ending with the latest.
+	   *
 	   * @param {Array} intervals
 	   * @return {Array}
 	   */
@@ -6310,15 +6362,27 @@
 	// This is safe for quickDT (used by local() and utc()) because we don't fill in
 	// higher-order units from tsNow (as we do in fromObject, this requires that
 	// offset is calculated from tsNow).
+	/**
+	 * @param {Zone} zone
+	 * @return {number}
+	 */
 	function guessOffsetForZone(zone) {
-	  if (!zoneOffsetGuessCache[zone]) {
-	    if (zoneOffsetTs === undefined) {
-	      zoneOffsetTs = Settings.now();
-	    }
+	  if (zoneOffsetTs === undefined) {
+	    zoneOffsetTs = Settings.now();
+	  }
 
-	    zoneOffsetGuessCache[zone] = zone.offset(zoneOffsetTs);
+	  // Do not cache anything but IANA zones, because it is not safe to do so.
+	  // Guessing an offset which is not present in the zone can cause wrong results from fixOffset
+	  if (zone.type !== "iana") {
+	    return zone.offset(zoneOffsetTs);
+	  }
+	  const zoneName = zone.name;
+	  let offsetGuess = zoneOffsetGuessCache.get(zoneName);
+	  if (offsetGuess === undefined) {
+	    offsetGuess = zone.offset(zoneOffsetTs);
+	    zoneOffsetGuessCache.set(zoneName, offsetGuess);
 	  }
-	  return zoneOffsetGuessCache[zone];
+	  return offsetGuess;
 	}
 
 	// this is a dumbed down version of fromObject() that runs about 60% faster
@@ -6408,7 +6472,7 @@
 	 * This optimizes quickDT via guessOffsetForZone to avoid repeated calls of
 	 * zone.offset().
 	 */
-	let zoneOffsetGuessCache = {};
+	const zoneOffsetGuessCache = new Map();
 
 	/**
 	 * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them.
@@ -6612,7 +6676,7 @@
 	      throw new InvalidArgumentError(
 	        `fromMillis requires a numerical input, but received a ${typeof milliseconds} with value ${milliseconds}`
 	      );
-	    } else if (milliseconds < -MAX_DATE || milliseconds > MAX_DATE) {
+	    } else if (milliseconds < -864e13 || milliseconds > MAX_DATE) {
 	      // this isn't perfect because we can still end up out of range because of additional shifting, but it's a start
 	      return DateTime.invalid("Timestamp out of range");
 	    } else {
@@ -6973,7 +7037,7 @@
 
 	  static resetCache() {
 	    zoneOffsetTs = undefined;
-	    zoneOffsetGuessCache = {};
+	    zoneOffsetGuessCache.clear();
 	  }
 
 	  // INFO
@@ -7742,7 +7806,7 @@
 	   * @example DateTime.now().toISO() //=> '2017-04-22T20:47:05.335-04:00'
 	   * @example DateTime.now().toISO({ includeOffset: false }) //=> '2017-04-22T20:47:05.335'
 	   * @example DateTime.now().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400'
-	   * @return {string}
+	   * @return {string|null}
 	   */
 	  toISO({
 	    format = "extended",
@@ -7769,7 +7833,7 @@
 	   * @param {string} [opts.format='extended'] - choose between the basic and extended format
 	   * @example DateTime.utc(1982, 5, 25).toISODate() //=> '1982-05-25'
 	   * @example DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525'
-	   * @return {string}
+	   * @return {string|null}
 	   */
 	  toISODate({ format = "extended" } = {}) {
 	    if (!this.isValid) {
@@ -7854,7 +7918,7 @@
 	  /**
 	   * Returns a string representation of this DateTime appropriate for use in SQL Date
 	   * @example DateTime.utc(2014, 7, 13).toSQLDate() //=> '2014-07-13'
-	   * @return {string}
+	   * @return {string|null}
 	   */
 	  toSQLDate() {
 	    if (!this.isValid) {
@@ -7949,7 +8013,7 @@
 	  }
 
 	  /**
-	   * Returns the epoch seconds of this DateTime.
+	   * Returns the epoch seconds (including milliseconds in the fractional part) of this DateTime.
 	   * @return {number}
 	   */
 	  toSeconds() {
@@ -8056,7 +8120,7 @@
 	  /**
 	   * Return an Interval spanning between this DateTime and another DateTime
 	   * @param {DateTime} otherDateTime - the other end point of the Interval
-	   * @return {Interval}
+	   * @return {Interval|DateTime}
 	   */
 	  until(otherDateTime) {
 	    return this.isValid ? Interval.fromDateTimes(this, otherDateTime) : this;
@@ -8649,7 +8713,6 @@
 	      return str;
 	    }
 	    const matches = str.match(
-	      // eslint-disable-next-line
 	      /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g
 	    );
 	    if (!matches) {
@@ -9018,75 +9081,42 @@
 	})(RpcMethod || {});
 
 	class Result {
-	  _errorCollection;
+	  _errors;
 	  _data;
-	  constructor() {
-	    this._errorCollection = /* @__PURE__ */ new Set();
-	    this._data = null;
+	  constructor(data) {
+	    this._errors = /* @__PURE__ */ new Map();
+	    this._data = data ?? null;
 	  }
-	  /**
-	   * Getter for the `isSuccess` property.
-	   * Checks if the `_errorCollection` is empty to determine success.
-	   *
-	   * @returns Whether the operation resulted in success (no errors).
-	   */
 	  get isSuccess() {
-	    return this._errorCollection.size === 0;
+	    return this._errors.size === 0;
+	  }
+	  get errors() {
+	    return this._errors;
 	  }
-	  /**
-	   * Sets the data associated with the result.
-	   *
-	   * @param data The data to be stored in the result.
-	   * @returns The current Result object for chaining methods.
-	   */
 	  setData(data) {
 	    this._data = data;
 	    return this;
 	  }
-	  /**
-	   * Retrieves the data associated with the result.
-	   *
-	   * @returns The data stored in the result, if any.
-	   */
 	  getData() {
 	    return this._data;
 	  }
-	  /**
-	   * Adds an error message or Error object to the result.
-	   *
-	   * @param error The error message or Error object to be added.
-	   * @returns The current Result object for chaining methods.
-	   */
-	  addError(error) {
-	    if (error instanceof Error) {
-	      this._errorCollection.add(error);
-	    } else {
-	      this._errorCollection.add(new Error(error.toString()));
-	    }
+	  addError(error, key) {
+	    const errorKey = key ?? Text.getUuidRfc4122();
+	    const errorObj = typeof error === "string" ? new Error(error) : error;
+	    this._errors.set(errorKey, errorObj);
 	    return this;
 	  }
-	  /**
-	   * Adds multiple errors to the result in a single call.
-	   *
-	   * @param errors An array of errors or strings that will be converted to errors.
-	   * @returns The current Result object for chaining methods.
-	   */
 	  addErrors(errors) {
 	    for (const error of errors) {
-	      if (error instanceof Error) {
-	        this._errorCollection.add(error);
-	      } else {
-	        this._errorCollection.add(new Error(error.toString()));
-	      }
+	      this.addError(error);
 	    }
 	    return this;
 	  }
-	  /**
-	   * Retrieves an iterator for the errors collected in the result.
-	   * @returns An iterator over the stored Error objects.
-	   */
 	  getErrors() {
-	    return this._errorCollection.values();
+	    return this._errors.values();
+	  }
+	  hasError(key) {
+	    return this._errors.has(key);
 	  }
 	  /**
 	   * Retrieves an array of error messages from the collected errors.
@@ -9095,7 +9125,7 @@
 	   *          contains the message of a corresponding error object.
 	   */
 	  getErrorMessages() {
-	    return [...this.getErrors()].map((error) => error.message);
+	    return Array.from(this._errors.values(), (e) => e.message);
 	  }
 	  /**
 	   * Converts the Result object to a string.
@@ -9103,36 +9133,168 @@
 	   * @returns {string} Returns a string representation of the result operation
 	   */
 	  toString() {
-	    if (this.isSuccess) {
-	      return `Result (success): data: ${JSON.stringify(this._data)}`;
+	    const status = this.isSuccess ? "success" : "failure";
+	    const data = this.safeStringify(this._data);
+	    return this.isSuccess ? `Result(${status}): ${data}` : `Result(${status}): ${data}
+Errors: ${this.getErrorMessages().join(", ")}`;
+	  }
+	  safeStringify(data) {
+	    try {
+	      return JSON.stringify(data, this.replacer, 2);
+	    } catch {
+	      return "[Unable to serialize data]";
 	    }
-	    return `Result (failure): errors: ${this.getErrorMessages().join(", ")}`;
+	  }
+	  replacer(_, value) {
+	    if (value instanceof Error) {
+	      return {
+	        name: value.name,
+	        message: value.message,
+	        stack: value.stack
+	      };
+	    }
+	    return value;
+	  }
+	  // Static constructors
+	  static ok(data) {
+	    return new Result(data);
+	  }
+	  static fail(error, key) {
+	    return new Result().addError(error, key);
 	  }
 	}
 
 	class AjaxError extends Error {
-	  cause;
+	  code;
 	  _status;
-	  _answerError;
-	  constructor(params) {
-	    const message = `${params.answerError.error}${params.answerError.errorDescription ? ": " + params.answerError.errorDescription : ""}`;
+	  requestInfo;
+	  timestamp;
+	  originalError;
+	  // override cause: null | Error
+	  // private _status: number
+	  // private _answerError: AnswerError
+	  constructor(details) {
+	    const message = AjaxError.formatErrorMessage(details);
 	    super(message);
-	    this.cause = params.cause || null;
-	    this.name = this.constructor.name;
-	    this._status = params.status;
-	    this._answerError = params.answerError;
-	  }
+	    this.name = "AjaxError";
+	    this.code = details.code;
+	    this._status = details.status;
+	    this.requestInfo = details.requestInfo;
+	    this.originalError = details.originalError;
+	    this.timestamp = /* @__PURE__ */ new Date();
+	    this.cleanErrorStack();
+	  }
+	  // constructor(params: AjaxErrorParams) {
+	  //   const message = `${ params.answerError.error }${
+	  //     params.answerError.errorDescription
+	  //       ? ': ' + params.answerError.errorDescription
+	  //       : ''
+	  //   }`
+	  //
+	  //   super(message)
+	  //   this.cause = params.cause || null
+	  //   this.name = this.constructor.name
+	  //
+	  //   this._status = params.status
+	  //   this._answerError = params.answerError
+	  // }
+	  /**
+	   * @deprecated
+	   */
 	  get answerError() {
-	    return this._answerError;
+	    return {
+	      error: this.message,
+	      errorDescription: ""
+	    };
 	  }
 	  get status() {
 	    return this._status;
 	  }
+	  /**
+	   * @deprecated
+	   */
 	  set status(status) {
 	    this._status = status;
 	  }
+	  /**
+	   * Creates AjaxError from HTTP response
+	   */
+	  static fromResponse(response) {
+	    return new AjaxError({
+	      code: response.data?.error || "unknown_error",
+	      description: response.data?.error_description,
+	      status: response.status,
+	      requestInfo: {
+	        method: response.config?.method?.toUpperCase(),
+	        url: response.config?.url,
+	        params: response.config?.params
+	      }
+	    });
+	  }
+	  /**
+	   * Creates AjaxError from exception
+	   */
+	  static fromException(error, context) {
+	    if (error instanceof AjaxError) return error;
+	    return new AjaxError({
+	      code: context?.code || "internal_error",
+	      status: context?.status || 500,
+	      description: error instanceof Error ? error.message : String(error),
+	      requestInfo: context?.requestInfo,
+	      originalError: error
+	    });
+	  }
+	  /**
+	   * Serializes error for logging and debugging
+	   */
+	  toJSON() {
+	    return {
+	      name: this.name,
+	      code: this.code,
+	      message: this.message,
+	      status: this._status,
+	      timestamp: this.timestamp.toISOString(),
+	      requestInfo: this.requestInfo,
+	      stack: this.stack
+	    };
+	  }
+	  // override toString(): string {
+	  //   return `${ this.answerError.error }${
+	  //     this.answerError.errorDescription
+	  //       ? ': ' + this.answerError.errorDescription
+	  //       : ''
+	  //   } (${ this.status })`
+	  // }
+	  /**
+	   * Formats error information for human-readable output
+	   */
 	  toString() {
-	    return `${this.answerError.error}${this.answerError.errorDescription ? ": " + this.answerError.errorDescription : ""} (${this.status})`;
+	    let output = `[${this.name}] ${this.code} (${this._status}): ${this.message}`;
+	    if (this.requestInfo) {
+	      output += `
+Request: ${this.requestInfo.method} ${this.requestInfo.url}`;
+	    }
+	    if (this.stack) {
+	      output += `
+Stack trace:
+${this.stack}`;
+	    }
+	    return output;
+	  }
+	  static formatErrorMessage(details) {
+	    const parts = [details.code];
+	    if (details.description) {
+	      parts.push(`- ${details.description}`);
+	    }
+	    if (details.requestInfo?.method && details.requestInfo.url) {
+	      parts.push(`(on ${details.requestInfo.method} ${details.requestInfo.url})`);
+	    }
+	    return parts.join(" ");
+	  }
+	  cleanErrorStack() {
+	    if (typeof this.stack === "string") {
+	      this.stack = this.stack.split("\n").filter((line) => !line.includes("AjaxError.constructor")).join("\n");
+	    }
 	  }
 	}
 
@@ -9140,31 +9302,48 @@
 	  _status;
 	  _query;
 	  _data;
-	  constructor(answer, query, status) {
+	  constructor(options) {
 	    super();
-	    this._data = answer;
-	    this._query = structuredClone(query);
-	    this._status = status;
-	    if (typeof this._data.error !== "undefined") {
-	      const error = typeof this._data.error === "string" ? this._data : this._data.error;
-	      this.addError(
-	        new AjaxError({
-	          status: this._status,
-	          answerError: {
-	            error: error.error || "",
-	            errorDescription: error.error_description || ""
-	          }
-	        })
-	      );
-	    }
-	  }
-	  // @ts-ignore
-	  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-	  setData(data) {
-	    throw new Error("AjaxResult not support setData()");
+	    this._data = Object.freeze(options.answer);
+	    this._query = Object.freeze(structuredClone(options.query));
+	    this._status = options.status;
+	    this.#processErrors();
+	  }
+	  #processErrors() {
+	    const { error } = this._data;
+	    if (!error) return;
+	    const errorParams = this.#normalizeError(error);
+	    this.addError(this.#createAjaxError(errorParams), "base-error");
+	  }
+	  #normalizeError(error) {
+	    return typeof error === "string" ? { code: error, description: this._data.error_description || "" } : { code: error.error, description: error.error_description || "" };
+	  }
+	  #createAjaxError(params) {
+	    return new AjaxError({
+	      code: String(this._status),
+	      description: params.description,
+	      status: this._status,
+	      requestInfo: {
+	        method: this._query.method,
+	        // url: '?',
+	        params: this._query.params
+	      }
+	      // request:
+	    });
 	  }
 	  getData() {
-	    return this._data;
+	    return Object.freeze({
+	      result: this._data.result,
+	      next: this._data.next,
+	      total: this._data.total,
+	      time: this._data.time
+	    });
+	  }
+	  /**
+	   * Alias for isMore
+	   */
+	  hasMore() {
+	    return this.isMore();
 	  }
 	  isMore() {
 	    return Type.isNumber(this._data?.next);
@@ -9178,16 +9357,35 @@
 	  getQuery() {
 	    return this._query;
 	  }
-	  async getNext(http) {
-	    if (this.isMore() && this.isSuccess) {
-	      this._query.start = Number.parseInt(this._data?.next);
-	      return http.call(
-	        this._query.method,
-	        this._query.params,
-	        this._query.start
-	      );
+	  /**
+	   * Alias for getNext
+	   * @param http
+	   */
+	  async fetchNext(http) {
+	    const data = await this.getNext(http);
+	    if (data === false) {
+	      return null;
 	    }
-	    return Promise.resolve(false);
+	    return data;
+	  }
+	  async getNext(http) {
+	    if (!this.isMore() || !this.isSuccess) return false;
+	    const nextPageQuery = this.#buildNextPageQuery();
+	    return http.call(
+	      nextPageQuery.method,
+	      nextPageQuery.params,
+	      nextPageQuery.start
+	    );
+	  }
+	  #buildNextPageQuery() {
+	    return {
+	      ...this._query,
+	      start: Text.toInteger(this._data.next)
+	    };
+	  }
+	  // Immutable API
+	  setData() {
+	    throw new ReferenceError("AjaxResult does not allow data modification");
 	  }
 	}
 
@@ -9842,7 +10040,7 @@
 	 *
 	 * @returns {boolean} True if value is a RegExp object, otherwise false
 	 */
-	const isRegExp$1 = kindOfTest('RegExp');
+	const isRegExp = kindOfTest('RegExp');
 
 	const reduceDescriptors = (obj, reducer) => {
 	  const descriptors = Object.getOwnPropertyDescriptors(obj);
@@ -9909,26 +10107,6 @@
 	  return value != null && Number.isFinite(value = +value) ? value : defaultValue;
 	};
 
-	const ALPHA = 'abcdefghijklmnopqrstuvwxyz';
-
-	const DIGIT = '0123456789';
-
-	const ALPHABET = {
-	  DIGIT,
-	  ALPHA,
-	  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
-	};
-
-	const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
-	  let str = '';
-	  const {length} = alphabet;
-	  while (size--) {
-	    str += alphabet[Math.random() * length|0];
-	  }
-
-	  return str;
-	};
-
 	/**
 	 * If the thing is a FormData object, return true, otherwise return false.
 	 *
@@ -10025,7 +10203,7 @@
 	  isDate,
 	  isFile,
 	  isBlob,
-	  isRegExp: isRegExp$1,
+	  isRegExp,
 	  isFunction,
 	  isStream,
 	  isURLSearchParams,
@@ -10056,8 +10234,6 @@
 	  findKey,
 	  global: _global,
 	  isContextDefined,
-	  ALPHABET,
-	  generateString,
 	  isSpecCompliantForm,
 	  toJSONObject,
 	  isAsyncFn,
@@ -10454,7 +10630,7 @@
 	 *
 	 * @param {string} url The base of the url (e.g., http://www.google.com)
 	 * @param {object} [params] The params to be appended
-	 * @param {?object} options
+	 * @param {?(object|Function)} options
 	 *
 	 * @returns {string} The formatted url
 	 */
@@ -10466,6 +10642,12 @@
 	  
 	  const _encode = options && options.encode || encode$1;
 
+	  if (utils$1.isFunction(options)) {
+	    options = {
+	      serialize: options
+	    };
+	  } 
+
 	  const serializeFn = options && options.serialize;
 
 	  let serializedParams;
@@ -10761,7 +10943,7 @@
 	    }
 	  }
 
-	  return (0, JSON.stringify)(rawValue);
+	  return (encoder || JSON.stringify)(rawValue);
 	}
 
 	const defaults$2 = {
@@ -11448,68 +11630,18 @@
 
 	const asyncDecorator = (fn) => (...args) => utils$1.asap(() => fn(...args));
 
-	const isURLSameOrigin = platform.hasStandardBrowserEnv ?
-
-	// Standard browser envs have full support of the APIs needed to test
-	// whether the request URL is of the same origin as current location.
-	  (function standardBrowserEnv() {
-	    const msie = platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent);
-	    const urlParsingNode = document.createElement('a');
-	    let originURL;
+	const isURLSameOrigin = platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
+	  url = new URL(url, platform.origin);
 
-	    /**
-	    * Parse a URL to discover its components
-	    *
-	    * @param {String} url The URL to be parsed
-	    * @returns {Object}
-	    */
-	    function resolveURL(url) {
-	      let href = url;
-
-	      if (msie) {
-	        // IE needs attribute set twice to normalize properties
-	        urlParsingNode.setAttribute('href', href);
-	        href = urlParsingNode.href;
-	      }
-
-	      urlParsingNode.setAttribute('href', href);
-
-	      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
-	      return {
-	        href: urlParsingNode.href,
-	        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
-	        host: urlParsingNode.host,
-	        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
-	        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
-	        hostname: urlParsingNode.hostname,
-	        port: urlParsingNode.port,
-	        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
-	          urlParsingNode.pathname :
-	          '/' + urlParsingNode.pathname
-	      };
-	    }
-
-	    originURL = resolveURL(window.location.href);
-
-	    /**
-	    * Determine if a URL shares the same origin as the current location
-	    *
-	    * @param {String} requestURL The URL to test
-	    * @returns {boolean} True if URL shares the same origin, otherwise false
-	    */
-	    return function isURLSameOrigin(requestURL) {
-	      const parsed = (utils$1.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
-	      return (parsed.protocol === originURL.protocol &&
-	          parsed.host === originURL.host);
-	    };
-	  })() :
-
-	  // Non standard browser envs (web workers, react-native) lack needed support.
-	  (function nonStandardBrowserEnv() {
-	    return function isURLSameOrigin() {
-	      return true;
-	    };
-	  })();
+	  return (
+	    origin.protocol === url.protocol &&
+	    origin.host === url.host &&
+	    (isMSIE || origin.port === url.port)
+	  );
+	})(
+	  new URL(platform.origin),
+	  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
+	) : () => true;
 
 	const cookies = platform.hasStandardBrowserEnv ?
 
@@ -11588,8 +11720,9 @@
 	 *
 	 * @returns {string} The combined full path
 	 */
-	function buildFullPath(baseURL, requestedURL) {
-	  if (baseURL && !isAbsoluteURL(requestedURL)) {
+	function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+	  let isRelativeUrl = !isAbsoluteURL(requestedURL);
+	  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
 	    return combineURLs(baseURL, requestedURL);
 	  }
 	  return requestedURL;
@@ -11611,7 +11744,7 @@
 	  config2 = config2 || {};
 	  const config = {};
 
-	  function getMergedValue(target, source, caseless) {
+	  function getMergedValue(target, source, prop, caseless) {
 	    if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
 	      return utils$1.merge.call({caseless}, target, source);
 	    } else if (utils$1.isPlainObject(source)) {
@@ -11623,11 +11756,11 @@
 	  }
 
 	  // eslint-disable-next-line consistent-return
-	  function mergeDeepProperties(a, b, caseless) {
+	  function mergeDeepProperties(a, b, prop , caseless) {
 	    if (!utils$1.isUndefined(b)) {
-	      return getMergedValue(a, b, caseless);
+	      return getMergedValue(a, b, prop , caseless);
 	    } else if (!utils$1.isUndefined(a)) {
-	      return getMergedValue(undefined, a, caseless);
+	      return getMergedValue(undefined, a, prop , caseless);
 	    }
 	  }
 
@@ -11685,7 +11818,7 @@
 	    socketPath: defaultToConfig2,
 	    responseEncoding: defaultToConfig2,
 	    validateStatus: mergeDirectKeys,
-	    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)
+	    headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
 	  };
 
 	  utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
@@ -11704,7 +11837,7 @@
 
 	  newConfig.headers = headers = AxiosHeaders$1.from(headers);
 
-	  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);
+	  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
 
 	  // HTTP basic authentication
 	  if (auth) {
@@ -12427,7 +12560,7 @@
 	  });
 	}
 
-	const VERSION$1 = "1.7.7";
+	const VERSION$1 = "1.8.4";
 
 	const validators$1 = {};
 
@@ -12478,6 +12611,14 @@
 	  };
 	};
 
+	validators$1.spelling = function spelling(correctSpelling) {
+	  return (value, opt) => {
+	    // eslint-disable-next-line no-console
+	    console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
+	    return true;
+	  }
+	};
+
 	/**
 	 * Assert object's properties type
 	 *
@@ -12547,9 +12688,9 @@
 	      return await this._request(configOrUrl, config);
 	    } catch (err) {
 	      if (err instanceof Error) {
-	        let dummy;
+	        let dummy = {};
 
-	        Error.captureStackTrace ? Error.captureStackTrace(dummy = {}) : (dummy = new Error());
+	        Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());
 
 	        // slice off the Error: ... line
 	        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
@@ -12604,6 +12745,18 @@
 	      }
 	    }
 
+	    // Set config.allowAbsoluteUrls
+	    if (config.allowAbsoluteUrls !== undefined) ; else if (this.defaults.allowAbsoluteUrls !== undefined) {
+	      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
+	    } else {
+	      config.allowAbsoluteUrls = true;
+	    }
+
+	    validator.assertOptions(config, {
+	      baseUrl: validators.spelling('baseURL'),
+	      withXsrfToken: validators.spelling('withXSRFToken')
+	    }, true);
+
 	    // Set config.method
 	    config.method = (config.method || this.defaults.method || 'get').toLowerCase();
 
@@ -12694,7 +12847,7 @@
 
 	  getUri(config) {
 	    config = mergeConfig$1(this.defaults, config);
-	    const fullPath = buildFullPath(config.baseURL, config.url);
+	    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
 	    return buildURL(fullPath, config.params, config.paramsSerializer);
 	  }
 	};
@@ -13079,7 +13232,7 @@
 
 	const formats = Format.RFC3986;
 
-	const has$2 = Object.prototype.hasOwnProperty;
+	const has$1 = Object.prototype.hasOwnProperty;
 	const isArray$2 = Array.isArray;
 
 	const hexTable = (function () {
@@ -13133,7 +13286,7 @@
 	    } else if (target && typeof target === 'object') {
 	      if (
 	        (options && (options.plainObjects || options.allowPrototypes)) ||
-	        !has$2.call(Object.prototype, source)
+	        !has$1.call(Object.prototype, source)
 	      ) {
 	        target[source] = true;
 	      }
@@ -13155,7 +13308,7 @@
 
 	  if (isArray$2(target) && isArray$2(source)) {
 	    source.forEach(function (item, i) {
-	      if (has$2.call(target, i)) {
+	      if (has$1.call(target, i)) {
 	        const targetItem = target[i];
 	        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
 	          target[i] = merge(targetItem, item, options);
@@ -13172,7 +13325,7 @@
 	  return Object.keys(source).reduce(function (acc, key) {
 	    const value = source[key];
 
-	    if (has$2.call(acc, key)) {
+	    if (has$1.call(acc, key)) {
 	      acc[key] = merge(acc[key], value, options);
 	    } else {
 	      acc[key] = value;
@@ -13296,10 +13449,6 @@
 	  return value
 	};
 
-	const isRegExp = function isRegExp(obj) {
-	  return Object.prototype.toString.call(obj) === '[object RegExp]'
-	};
-
 	const isBuffer = function isBuffer(obj) {
 	  if (!obj || typeof obj !== 'object') {
 	    return false
@@ -13323,8 +13472,6 @@
 	  return fn(val)
 	};
 
-	const has$1 = Object.prototype.hasOwnProperty;
-
 	const arrayPrefixGenerators = {
 	  brackets: function brackets(prefix) {
 	    return prefix + '[]'
@@ -13407,7 +13554,7 @@
 	  let tmpSc = sideChannel;
 	  let step = 0;
 	  let findFlag = false;
-	  while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) {
+	  while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
 	    // Where object last appeared in the ref tree
 	    const pos = tmpSc.get(object);
 	    step += 1;
@@ -13472,7 +13619,7 @@
 	    if (encodeValuesOnly && encoder) {
 	      obj = maybeMap(obj, encoder);
 	    }
-	    objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
+	    objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void 0 }];
 	  } else if (isArray$1(filter)) {
 	    objKeys = filter;
 	  } else {
@@ -13536,108 +13683,14 @@
 	};
 
 	const normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
-	  if (!opts) {
+	  {
 	    return defaults$1
 	  }
-
-	  if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
-	    throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided')
-	  }
-
-	  if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {
-	    throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided')
-	  }
-
-	  if (
-	    opts.encoder !== null &&
-	    typeof opts.encoder !== 'undefined' &&
-	    typeof opts.encoder !== 'function'
-	  ) {
-	    throw new TypeError('Encoder has to be a function.')
-	  }
-
-	  const charset = opts.charset || defaults$1.charset;
-	  if (
-	    typeof opts.charset !== 'undefined' &&
-	    opts.charset !== 'utf-8' &&
-	    opts.charset !== 'iso-8859-1'
-	  ) {
-	    throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined')
-	  }
-
-	  let format = formats;
-	  if (typeof opts.format !== 'undefined') {
-	    if (!has$1.call(formatters, opts.format)) {
-	      throw new TypeError('Unknown format option provided.')
-	    }
-	    format = opts.format;
-	  }
-	  const formatter = formatters[format];
-
-	  let filter = defaults$1.filter;
-	  if (typeof opts.filter === 'function' || isArray$1(opts.filter)) {
-	    filter = opts.filter;
-	  }
-
-	  let arrayFormat;
-	  if (opts.arrayFormat in arrayPrefixGenerators) {
-	    arrayFormat = opts.arrayFormat;
-	  } else if ('indices' in opts) {
-	    arrayFormat = opts.indices ? 'indices' : 'repeat';
-	  } else {
-	    arrayFormat = defaults$1.arrayFormat;
-	  }
-
-	  if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
-	    throw new TypeError('`commaRoundTrip` must be a boolean, or absent')
-	  }
-
-	  const allowDots =
-	    typeof opts.allowDots === 'undefined'
-	      ? opts.encodeDotInKeys === true
-	        ? true
-	        : defaults$1.allowDots
-	      : !!opts.allowDots;
-
-	  return {
-	    addQueryPrefix:
-	      typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults$1.addQueryPrefix,
-	    allowDots: allowDots,
-	    allowEmptyArrays:
-	      typeof opts.allowEmptyArrays === 'boolean'
-	        ? !!opts.allowEmptyArrays
-	        : defaults$1.allowEmptyArrays,
-	    arrayFormat: arrayFormat,
-	    charset: charset,
-	    charsetSentinel:
-	      typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults$1.charsetSentinel,
-	    commaRoundTrip: opts.commaRoundTrip,
-	    delimiter: typeof opts.delimiter === 'undefined' ? defaults$1.delimiter : opts.delimiter,
-	    encode: typeof opts.encode === 'boolean' ? opts.encode : defaults$1.encode,
-	    encodeDotInKeys:
-	      typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults$1.encodeDotInKeys,
-	    encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults$1.encoder,
-	    encodeValuesOnly:
-	      typeof opts.encodeValuesOnly === 'boolean'
-	        ? opts.encodeValuesOnly
-	        : defaults$1.encodeValuesOnly,
-	    filter: filter,
-	    format: format,
-	    formatter: formatter,
-	    serializeDate:
-	      typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults$1.serializeDate,
-	    skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults$1.skipNulls,
-	    sort: typeof opts.sort === 'function' ? opts.sort : null,
-	    strictNullHandling:
-	      typeof opts.strictNullHandling === 'boolean'
-	        ? opts.strictNullHandling
-	        : defaults$1.strictNullHandling,
-	  }
 	};
 
 	function stringify(object, opts) {
 	  let obj = object;
-	  const options = normalizeStringifyOptions(opts);
+	  const options = normalizeStringifyOptions();
 
 	  let objKeys;
 	  let filter;
@@ -13920,91 +13973,13 @@
 	};
 
 	const normalizeParseOptions = function normalizeParseOptions(opts) {
-	  if (!opts) {
+	  {
 	    return defaults
 	  }
-
-	  if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
-	    throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided')
-	  }
-
-	  if (typeof opts.decodeDotInKeys !== 'undefined' && typeof opts.decodeDotInKeys !== 'boolean') {
-	    throw new TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided')
-	  }
-
-	  if (
-	    opts.decoder !== null &&
-	    typeof opts.decoder !== 'undefined' &&
-	    typeof opts.decoder !== 'function'
-	  ) {
-	    throw new TypeError('Decoder has to be a function.')
-	  }
-
-	  if (
-	    typeof opts.charset !== 'undefined' &&
-	    opts.charset !== 'utf-8' &&
-	    opts.charset !== 'iso-8859-1'
-	  ) {
-	    throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined')
-	  }
-	  const charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;
-
-	  const duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;
-
-	  if (duplicates !== 'combine' && duplicates !== 'first' && duplicates !== 'last') {
-	    throw new TypeError('The duplicates option must be either combine, first, or last')
-	  }
-
-	  const allowDots =
-	    typeof opts.allowDots === 'undefined'
-	      ? opts.decodeDotInKeys === true
-	        ? true
-	        : defaults.allowDots
-	      : !!opts.allowDots;
-
-	  return {
-	    allowDots: allowDots,
-	    allowEmptyArrays:
-	      typeof opts.allowEmptyArrays === 'boolean'
-	        ? !!opts.allowEmptyArrays
-	        : defaults.allowEmptyArrays,
-	    allowPrototypes:
-	      typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
-	    allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,
-	    arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
-	    charset: charset,
-	    charsetSentinel:
-	      typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
-	    comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
-	    decodeDotInKeys:
-	      typeof opts.decodeDotInKeys === 'boolean' ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
-	    decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
-	    delimiter:
-	      typeof opts.delimiter === 'string' || isRegExp(opts.delimiter)
-	        ? opts.delimiter
-	        : defaults.delimiter,
-	    // eslint-disable-next-line no-implicit-coercion, no-extra-parens
-	    depth: typeof opts.depth === 'number' || opts.depth === false ? +opts.depth : defaults.depth,
-	    duplicates: duplicates,
-	    ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
-	    interpretNumericEntities:
-	      typeof opts.interpretNumericEntities === 'boolean'
-	        ? opts.interpretNumericEntities
-	        : defaults.interpretNumericEntities,
-	    parameterLimit:
-	      typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
-	    parseArrays: opts.parseArrays !== false,
-	    plainObjects:
-	      typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
-	    strictNullHandling:
-	      typeof opts.strictNullHandling === 'boolean'
-	        ? opts.strictNullHandling
-	        : defaults.strictNullHandling,
-	  }
 	};
 
 	function parse(str, opts) {
-	  const options = normalizeParseOptions(opts);
+	  const options = normalizeParseOptions();
 
 	  if (str === '' || str === null || typeof str === 'undefined') {
 	    return options.plainObjects ? Object.create(null) : {}
@@ -14100,33 +14075,37 @@
 	  // endregion ////
 	  // region Actions Call ////
 	  async batch(calls, isHaltOnError = true) {
-	    const isArrayMode = Array.isArray(calls);
-	    const cmd = isArrayMode ? [] : {};
+	    if (Array.isArray(calls)) {
+	      return this.#batchAsArray(
+	        calls,
+	        isHaltOnError
+	      );
+	    }
+	    return this.#batchAsObject(
+	      calls,
+	      isHaltOnError
+	    );
+	  }
+	  async #batchAsObject(calls, isHaltOnError = true) {
+	    const cmd = {};
 	    let cnt = 0;
 	    const processRow = (row, index) => {
 	      let method = null;
 	      let params = null;
-	      if (Array.isArray(row)) {
-	        method = row[0];
-	        params = row[1];
-	      } else if (row.method) {
-	        method = row.method;
-	        params = row.params;
+	      if (row.method) {
+	        method = row.method ?? null;
+	        params = row?.params ?? null;
+	      } else if (Array.isArray(row) && row.length > 0) {
+	        method = row[0] ?? null;
+	        params = row[1] ?? null;
 	      }
 	      if (method) {
 	        cnt++;
-	        const data = method + "?" + stringify(params);
-	        if (isArrayMode || Array.isArray(cmd)) {
-	          cmd.push(data);
-	        } else {
-	          cmd[index] = data;
-	        }
+	        cmd[index] = method + "?" + stringify(params);
 	      }
 	    };
-	    if (isArrayMode) {
-	      for (const [index, item] of calls.entries()) processRow(item, index);
-	    } else {
-	      for (const [index, item] of Object.entries(calls)) processRow(item, index);
+	    for (const [index, row] of Object.entries(calls)) {
+	      processRow(row, index);
 	    }
 	    if (cnt < 1) {
 	      return Promise.resolve(new Result());
@@ -14136,7 +14115,7 @@
 	      cmd
 	    }).then((response) => {
 	      const responseResult = response.getData().result;
-	      const results = isArrayMode ? [] : {};
+	      const results = {};
 	      const processResponse = (row, index) => {
 	        if (
 	          // @ts-ignore
@@ -14144,8 +14123,8 @@
 	          typeof responseResult.result_error[index] !== "undefined"
 	        ) {
 	          const q = row.split("?");
-	          const data = new AjaxResult(
-	            {
+	          results[index] = new AjaxResult({
+	            answer: {
 	              // @ts-ignore
 	              result: Type.isUndefined(responseResult.result[index]) ? (
 	                // @ts-ignore
@@ -14159,67 +14138,154 @@
 	              // @ts-ignore
 	              total: responseResult.result_total[index],
 	              // @ts-ignore
-	              next: responseResult.result_next[index]
+	              next: responseResult.result_next[index],
+	              // @todo test this ////
+	              // @ts-ignore
+	              time: responseResult.result_time[index]
 	            },
-	            {
+	            query: {
 	              method: q[0] || "",
 	              params: parse(q[1] || ""),
 	              start: 0
 	            },
-	            response.getStatus()
-	          );
-	          if (isArrayMode || Array.isArray(results)) {
-	            results.push(data);
-	          } else {
-	            results[index] = data;
-	          }
+	            status: response.getStatus()
+	          });
 	        }
 	      };
-	      if (Array.isArray(cmd)) {
-	        for (const [index, item] of cmd.entries()) processResponse(item, index);
-	      } else {
-	        for (const [index, item] of Object.entries(cmd))
-	          processResponse(item, index);
+	      for (const [index, row] of Object.entries(cmd)) {
+	        processResponse(row, index);
 	      }
-	      let dataResult;
+	      const dataResult = {};
 	      const initError = (result2) => {
+	        if (result2.hasError("base-error")) {
+	          return result2.errors.get("base-error");
+	        }
 	        return new AjaxError({
+	          code: "0",
+	          description: result2.getErrorMessages().join("; "),
 	          status: 0,
-	          answerError: {
-	            error: result2.getErrorMessages().join("; "),
-	            errorDescription: `batch ${result2.getQuery().method}: ${stringify(result2.getQuery().params, { encode: false })}`
+	          requestInfo: {
+	            method: result2.getQuery().method,
+	            params: result2.getQuery().params
 	          },
-	          cause: result2.getErrors().next().value
+	          originalError: result2.getErrors().next().value
 	        });
 	      };
 	      const result = new Result();
-	      if (isArrayMode || Array.isArray(results)) {
-	        dataResult = [];
-	        for (const data of results) {
-	          if (data.getStatus() !== 200 || !data.isSuccess) {
-	            const error = initError(data);
-	            if (!isHaltOnError && !data.isSuccess) {
-	              result.addError(error);
-	              continue;
-	            }
-	            return Promise.reject(error);
+	      for (const key of Object.keys(results)) {
+	        const data = results[key];
+	        if (data.getStatus() !== 200 || !data.isSuccess) {
+	          const error = initError(data);
+	          if (!isHaltOnError && !data.isSuccess) {
+	            result.addError(error, key);
+	            continue;
 	          }
-	          dataResult.push(data.getData().result);
+	          return Promise.reject(error);
 	        }
-	      } else {
-	        dataResult = {};
-	        for (const key of Object.keys(results)) {
-	          const data = results[key];
-	          if (data.getStatus() !== 200 || !data.isSuccess) {
-	            const error = initError(data);
-	            if (!isHaltOnError && !data.isSuccess) {
-	              result.addError(error);
-	              continue;
-	            }
-	            return Promise.reject(error);
+	        dataResult[key] = data.getData().result;
+	      }
+	      result.setData(dataResult);
+	      return Promise.resolve(result);
+	    });
+	  }
+	  async #batchAsArray(calls, isHaltOnError = true) {
+	    const cmd = [];
+	    let cnt = 0;
+	    const processRow = (row) => {
+	      let method = null;
+	      let params = null;
+	      if (row.method) {
+	        method = row.method ?? null;
+	        params = row?.params ?? null;
+	      } else if (Array.isArray(row) && row.length > 0) {
+	        method = row[0] ?? null;
+	        params = row[1] ?? null;
+	      }
+	      if (method) {
+	        cnt++;
+	        const data = method + "?" + stringify(params);
+	        cmd.push(data);
+	      }
+	    };
+	    for (const [_, row] of calls.entries()) {
+	      processRow(row);
+	    }
+	    if (cnt < 1) {
+	      return Promise.resolve(new Result());
+	    }
+	    return this.call("batch", {
+	      halt: isHaltOnError ? 1 : 0,
+	      cmd
+	    }).then((response) => {
+	      const responseResult = response.getData().result;
+	      const results = [];
+	      const processResponse = (row, index) => {
+	        if (
+	          // @ts-ignore
+	          typeof responseResult.result[index] !== "undefined" || // @ts-ignore
+	          typeof responseResult.result_error[index] !== "undefined"
+	        ) {
+	          const q = row.split("?");
+	          const data = new AjaxResult({
+	            answer: {
+	              // @ts-ignore
+	              result: Type.isUndefined(responseResult.result[index]) ? (
+	                // @ts-ignore
+	                {}
+	              ) : (
+	                // @ts-ignore
+	                responseResult.result[index]
+	              ),
+	              // @ts-ignore
+	              error: responseResult?.result_error[index] || void 0,
+	              // @ts-ignore
+	              total: responseResult.result_total[index],
+	              // @ts-ignore
+	              next: responseResult.result_next[index],
+	              // @todo test this ////
+	              // @ts-ignore
+	              time: responseResult.result_time[index]
+	            },
+	            query: {
+	              method: q[0] || "",
+	              params: parse(q[1] || ""),
+	              start: 0
+	            },
+	            status: response.getStatus()
+	          });
+	          results.push(data);
+	        }
+	      };
+	      for (const [index, row] of cmd.entries()) {
+	        processResponse(row, index);
+	      }
+	      const dataResult = [];
+	      const initError = (result2) => {
+	        if (result2.hasError("base-error")) {
+	          return result2.errors.get("base-error");
+	        }
+	        return new AjaxError({
+	          code: "0",
+	          description: result2.getErrorMessages().join("; "),
+	          status: 0,
+	          requestInfo: {
+	            method: result2.getQuery().method,
+	            params: result2.getQuery().params
+	          },
+	          originalError: result2.getErrors().next().value
+	        });
+	      };
+	      const result = new Result();
+	      for (const data of results) {
+	        if (data.getStatus() !== 200 || !data.isSuccess) {
+	          const error = initError(data);
+	          if (!isHaltOnError && !data.isSuccess) {
+	            result.addError(error);
+	            continue;
 	          }
-	          dataResult[key] = data.getData().result;
+	          return Promise.reject(error);
 	        }
+	        dataResult.push(data.getData().result);
 	      }
 	      result.setData(dataResult);
 	      return Promise.resolve(result);
@@ -14267,9 +14333,14 @@
 	          };
 	        }
 	        const problemError = new AjaxError({
+	          code: String(answerError.error),
+	          description: answerError.errorDescription,
 	          status: error_.response?.status || 0,
-	          answerError,
-	          cause: error_
+	          requestInfo: {
+	            method,
+	            params
+	          },
+	          originalError: error_
 	        });
 	        if (problemError.status === 401 && ["expired_token", "invalid_token"].includes(
 	          problemError.answerError.error
@@ -14303,9 +14374,14 @@
 	                };
 	              }
 	              const problemError2 = new AjaxError({
-	                status: error__.response?.status || 0,
-	                answerError: answerError2,
-	                cause: error__
+	                code: String(answerError2.error),
+	                description: answerError2.errorDescription,
+	                status: error_.response?.status || 0,
+	                requestInfo: {
+	                  method,
+	                  params
+	                },
+	                originalError: error__
 	              });
 	              return Promise.reject(problemError2);
 	            }
@@ -14314,15 +14390,15 @@
 	        return Promise.reject(problemError);
 	      }
 	    ).then((response) => {
-	      const result = new AjaxResult(
-	        response.payload,
-	        {
+	      const result = new AjaxResult({
+	        answer: response.payload,
+	        query: {
 	          method,
 	          params,
 	          start
 	        },
-	        response.status
-	      );
+	        status: response.status
+	      });
 	      return Promise.resolve(result);
 	    });
 	  }
@@ -14343,7 +14419,7 @@
 	      result.logTag = this.#logTag;
 	    }
 	    result[this.#requestIdGenerator.getQueryStringParameterName()] = this.#requestIdGenerator.getRequestId();
-	    result[this.#requestIdGenerator.getQueryStringSdkParameterName()] = "0.1.7";
+	    result[this.#requestIdGenerator.getQueryStringSdkParameterName()] = "0.2.1";
 	    if (!!result.data && !!result.data.start) {
 	      delete result.data.start;
 	    }
@@ -15505,11 +15581,13 @@
 	class MessageManager {
 	  #appFrame;
 	  #callbackPromises;
+	  #callbackSingletone;
 	  _logger = null;
 	  runCallbackHandler;
 	  constructor(appFrame) {
 	    this.#appFrame = appFrame;
 	    this.#callbackPromises = /* @__PURE__ */ new Map();
+	    this.#callbackSingletone = /* @__PURE__ */ new Map();
 	    this.runCallbackHandler = this._runCallback.bind(this);
 	  }
 	  setLogger(logger) {
@@ -15559,17 +15637,22 @@
 	        timeoutId: null
 	      };
 	      const keyPromise = this.#setCallbackPromise(promiseHandler);
+	      const paramsSend = omit(params || {}, ["callBack", "isSafely", "safelyTime"]);
+	      const { callBack } = params || {};
+	      if (callBack) {
+	        this.#callbackSingletone.set(keyPromise, callBack);
+	      }
 	      if (command.toString().includes(":")) {
 	        cmd = {
 	          method: command.toString(),
-	          params: params ?? "",
+	          params: paramsSend ?? "",
 	          callback: keyPromise,
 	          appSid: this.#appFrame.getAppSid()
 	        };
 	      } else {
 	        cmd = command.toString();
 	        const listParams = [
-	          params ? JSON.stringify(params) : null,
+	          params ? JSON.stringify(paramsSend) : null,
 	          keyPromise,
 	          this.#appFrame.getAppSid()
 	        ];
@@ -15624,6 +15707,11 @@
 	        }
 	        this.#callbackPromises.delete(cmd.id);
 	        promise.resolve(cmd.args);
+	      } else if (this.#callbackSingletone.has(cmd.id)) {
+	        const callBack = this.#callbackSingletone.get(cmd.id);
+	        if (callBack) {
+	          callBack.apply(globalThis, [cmd.args]);
+	        }
 	      }
 	    }
 	  }
@@ -16350,15 +16438,17 @@
 	  /**
 	   * Set Up the Interface Event Handler
 	   * @param {string} eventName
+	   * @param {(...args: any[]) => void} callBack
 	   * @return {Promise<any>}
 	   *
 	   * @link https://apidocs.bitrix24.com/api-reference/widgets/ui-interaction/bx24-placement-bind-event.html
 	   */
-	  async bindEvent(eventName) {
+	  async bindEvent(eventName, callBack) {
 	    return this.#messageManager.send(
-	      MessageCommands.getInterface,
+	      MessageCommands.placementBindEvent,
 	      {
 	        event: eventName,
+	        callBack,
 	        isSafely: true
 	      }
 	    );
@@ -24315,7 +24405,7 @@
 	    }
 	    if (message.extra.server_time_unix) {
 	      message.extra.server_time_ago = (Date.now() - message.extra.server_time_unix * 1e3) / 1e3 - (this._config?.server.timeShift || 0);
-	      message.extra.server_time_ago = message.extra.server_time_ago > 0 ? message.extra.server_time_ago : 0;
+	      message.extra.server_time_ago = Math.max(message.extra.server_time_ago, 0);
 	    }
 	    this.logMessage(message);
 	    try {
@@ -25381,7 +25471,7 @@ Data string: ${pullEvent}
 	  }
 	  trimDuplicates() {
 	    if (this._session.lastMessageIds.length > MAX_IDS_TO_STORE) {
-	      this._session.lastMessageIds = this._session.lastMessageIds.slice(-MAX_IDS_TO_STORE);
+	      this._session.lastMessageIds = this._session.lastMessageIds.slice(-10);
 	    }
 	  }
 	  // endregion ////
@@ -25459,19 +25549,19 @@ Data string: ${pullEvent}
 	   * @deprecated
 	   */
 	  /*/
-	  	getRestClientOptions()
-	  	{
-	  		let result = {};
+	    getRestClientOptions()
+	    {
+	      let result = {};
 	  
-	  		if (this.guestMode && this.guestUserId !== 0)
-	  		{
-	  			result.queryParams = {
-	  				pull_guest_id: this.guestUserId
-	  			}
-	  		}
-	  		return result;
-	  	}
-	  	//*/
+	      if (this.guestMode && this.guestUserId !== 0)
+	      {
+	        result.queryParams = {
+	          pull_guest_id: this.guestUserId
+	        }
+	      }
+	      return result;
+	    }
+	    //*/
 	  // endregion ////
 	}
 
@@ -26037,6 +26127,9 @@ Data string: ${pullEvent}
 	exports.TypeOption = TypeOption;
 	exports.TypeSpecificUrl = TypeSpecificUrl;
 	exports.initializeB24Frame = initializeB24Frame;
+	exports.isArrayOfArray = isArrayOfArray;
+	exports.omit = omit;
+	exports.pick = pick$1;
 	exports.useB24Helper = useB24Helper;
 	exports.useFormatter = useFormatter;