@bitrix24/b24jssdk 0.4.10 → 1.0.1

package/dist/esm/index.d.ts

@@ -1,5 +1,503 @@
+import { Writable } from 'node:stream';
 import { DateTimeOptions, DateTime } from 'luxon';
+import { AxiosInstance, AxiosError } from 'axios';
 
+/**
+ * Log levels in ascending order of severity.
+ *
+ * Levels allow filtering messages: when a specific level is set,
+ * messages of that level and all higher levels will be logged.
+ */
+declare enum LogLevel {
+    /**
+     * Detailed debug information for developers.
+     * Default level in development environment.
+     */
+    DEBUG = 0,
+    /**
+     * Informational messages about normal application operation.
+     * Used for tracking business logic.
+     */
+    INFO = 1,
+    /**
+     * Important but non-critical events.
+     * Examples: successful request processing, configuration changes.
+     */
+    NOTICE = 2,
+    /**
+     * Warnings about potential problems.
+     * Application continues to run but attention is required.
+     */
+    WARNING = 3,
+    /**
+     * Runtime errors requiring intervention.
+     * Some functionality is unavailable but the application is running.
+     */
+    ERROR = 4,
+    /**
+     * Critical errors disrupting component operation.
+     * Require immediate intervention during working hours.
+     */
+    CRITICAL = 5,
+    /**
+     * Serious problems requiring immediate resolution.
+     * Examples: database unavailable, disk space exhausted.
+     */
+    ALERT = 6,
+    /**
+     * System is unusable, requires urgent intervention.
+     * Highest severity level.
+     */
+    EMERGENCY = 7
+}
+type LogLevelName = keyof typeof LogLevel;
+interface LogRecord {
+    channel: string;
+    level: LogLevel;
+    levelName: LogLevelName;
+    message: string;
+    context: Record<string, any>;
+    extra: Record<string, any>;
+    timestamp: Date;
+}
+interface Formatter {
+    format(record: LogRecord): any;
+}
+interface HandlerOptions {
+    bubble?: boolean;
+    [key: string]: any;
+}
+interface Handler {
+    /**
+     * Handles a log record.
+     *
+     * @param {LogRecord} record - Log record to handle.
+     * @returns {boolean}
+     */
+    handle(record: LogRecord): Promise<boolean>;
+    isHandling(level: LogLevel): boolean;
+    shouldBubble(): boolean;
+    setFormatter(formatter: Formatter): void;
+    getFormatter(): Formatter | null;
+}
+type Processor = (record: LogRecord) => LogRecord;
+interface LoggerInterface {
+    /**
+     * Logs with an arbitrary level.
+     */
+    log(level: LogLevel, message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Detailed debug information.
+     */
+    debug(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Interesting events.
+     *
+     * Example: User logs in, SQL logs.
+     */
+    info(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Normal but significant events.
+     */
+    notice(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Exceptional occurrences that are not errors.
+     *
+     * Example: Use of deprecated APIs, poor use of an API, undesirable things
+     *          that are not necessarily wrong.
+     */
+    warning(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Runtime errors that do not require immediate action but should typically
+     * be logged and monitored.
+     */
+    error(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Critical conditions
+     *
+     * Example: Application component unavailable, unexpected exception
+     */
+    critical(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * Action must be taken immediately.
+     *
+     * Example: Entire website down, database unavailable, etc. This should
+     *          trigger the SMS alerts and wake you up.
+     */
+    alert(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * System is unusable.
+     */
+    emergency(message: string, context?: Record<string, any>): Promise<void>;
+}
+
+/**
+ * Support date format:
+ *  - `YYYY` - Full year (e.g., 2024)
+ *  - `YY` - Two-digit year (e.g., 24)
+ *  - `MMMM` - Full month name (e.g., "January")
+ *  - `MMM` - Abbreviated month name (e.g., "Jan")
+ *  - `MM` - Month with leading zero (01-12)
+ *  - `M` - Month without leading zero (1-12)
+ *  - `DD` - Day of month with leading zero (01-31)
+ *  - `D` - Day of month without leading zero (1-31)
+ *  - `HH` - Hour (24-hour) with leading zero (00-23)
+ *  - `H` - Hour (24-hour) without leading zero (0-23)
+ *  - `hh` - Hour (12-hour) with leading zero (00-11)
+ *  - `h` - Hour (12-hour) without leading zero (0-11)
+ *  - `mm` - Minutes with leading zero (00-59)
+ *  - `m` - Minutes without leading zero (0-59)
+ *  - `ss` - Seconds with leading zero (00-59)
+ *  - `s` - Seconds without leading zero (0-59)
+ *  - `SSS` - Milliseconds (000-999)
+ *  - `a` - AM/PM lowercase (am/pm)
+ *  - `A` - AM/PM uppercase (AM/PM)
+ *  - `ZZZ` - Timezone (e.g., UTC)
+ *  - `ZZ` - Timezone offset (e.g., +03:00)
+ */
+declare abstract class AbstractFormatter implements Formatter {
+    protected dateFormat: string;
+    constructor(dateFormat?: string);
+    abstract format(record: LogRecord): string;
+    protected _formatTimestamp(date: Date): string;
+    protected _formatDate(date: Date): string;
+}
+
+/**
+ * JsonFormatter
+ *
+ * @inheritDoc
+ */
+declare class JsonFormatter extends AbstractFormatter implements Formatter {
+    constructor(dateFormat?: string);
+    format(record: LogRecord): string;
+}
+
+/**
+ * LineFormatter
+ *
+ * @inheritDoc
+ */
+declare class LineFormatter extends AbstractFormatter implements Formatter {
+    protected formatString: string;
+    constructor(formatString?: string, dateFormat?: string);
+    format(record: LogRecord): string;
+}
+
+/**
+ * TelegramFormatter
+ *
+ * Formats a log entry for sending to Telegram.
+ * Supports HTML markup with escaped special characters.
+ *
+ * @link https://core.telegram.org/bots/api#html-style
+ */
+declare class TelegramFormatter extends AbstractFormatter implements Formatter {
+    private useHtml;
+    private maxMessageLength;
+    constructor(useHtml?: boolean, dateFormat?: string, maxMessageLength?: number);
+    format(record: LogRecord): string;
+    protected _formatBaseMessage(record: LogRecord): string;
+    protected _formatAdditionalInfo(record: LogRecord): string;
+    protected _escapeHtml(text: string): string;
+    protected _escapeMarkdownV2(text: string): string;
+    /**
+     * Set the use of HTML markup
+     */
+    setUseHtml(useHtml: boolean): this;
+    /**
+     * // Set the maximum message length
+     */
+    setMaxMessageLength(maxLength: number): this;
+}
+
+declare const pidProcessor: Processor;
+
+declare const memoryUsageProcessor: Processor;
+
+/**
+ * Abstract Handler
+ */
+declare abstract class AbstractHandler implements Handler {
+    protected level: LogLevel;
+    protected formatter: Formatter | null;
+    protected bubble: boolean;
+    constructor(level?: LogLevel, bubble?: boolean);
+    isHandling(level: LogLevel): boolean;
+    shouldBubble(): boolean;
+    setFormatter(formatter: Formatter): void;
+    getFormatter(): Formatter | null;
+    /**
+     * @inheritDoc
+     */
+    abstract handle(record: LogRecord): Promise<boolean>;
+}
+
+interface ConsoleHandlerOptions extends HandlerOptions {
+    useStyles?: boolean;
+}
+/**
+ * Console Handler
+ */
+declare class ConsoleHandler extends AbstractHandler implements Handler {
+    protected _styles: Map<LogLevel, string[]>;
+    protected readonly _useStyles: boolean;
+    constructor(level?: LogLevel, options?: ConsoleHandlerOptions);
+    protected _initStyles(): void;
+    /**
+     * @inheritDoc
+     */
+    handle(record: LogRecord): Promise<boolean>;
+    protected _getConsoleMethod(level: LogLevel): 'log' | 'info' | 'warn' | 'error' | 'trace';
+}
+
+/**
+ * Console Handler V2
+ */
+declare class ConsoleV2Handler extends ConsoleHandler implements Handler {
+    constructor(level?: LogLevel, options?: ConsoleHandlerOptions);
+    /**
+     * @inheritDoc
+     */
+    handle(record: LogRecord): Promise<boolean>;
+}
+
+interface MemoryHandlerOptions extends HandlerOptions {
+    limit?: number;
+}
+/**
+ * Memory Handler
+ */
+declare class MemoryHandler extends AbstractHandler implements Handler {
+    private records;
+    private readonly limit;
+    constructor(level?: LogLevel, options?: MemoryHandlerOptions);
+    /**
+     * @inheritDoc
+     */
+    handle(record: LogRecord): Promise<boolean>;
+    getRecords(): LogRecord[];
+    clear(): void;
+}
+
+interface StreamHandlerOptions extends HandlerOptions {
+    stream: Writable;
+}
+/**
+ * Stream Handler
+ *
+ * Node.js stream handler for writing logs to streams.
+ */
+declare class StreamHandler extends AbstractHandler implements Handler {
+    /**
+     * Stream for writing logs.
+     * @private
+     */
+    private stream;
+    /**
+     * Creates a StreamHandler instance.
+     *
+     * @param {LogLevel} level - Minimum log level.
+     * @param options
+     *     - `stream: Writable` - Stream to write to (e.g., `process.stdout`, `process.stderr`, `fs.WriteStream`)
+     *     - `bubble?: boolean` - Determines whether the handler should bubble the record to the next handler.
+     */
+    constructor(level: LogLevel | undefined, options: StreamHandlerOptions);
+    /**
+     * @inheritDoc
+     */
+    handle(record: LogRecord): Promise<boolean>;
+    /**
+     * Closes the stream (if supported).
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+}
+
+interface ConsolaAdapterOptions extends HandlerOptions {
+    consolaInstance: any;
+}
+/**
+ * Adapter for Consola
+ *
+ * @memo Consola has its own formatter
+ * @link https://github.com/unjs/consola
+ */
+declare class ConsolaAdapter extends AbstractHandler implements Handler {
+    private consolaInstance;
+    constructor(level: LogLevel | undefined, options: ConsolaAdapterOptions);
+    setFormatter(_formatter: Formatter): void;
+    getFormatter(): Formatter | null;
+    handle(record: LogRecord): Promise<boolean>;
+}
+
+interface WinstonAdapterOptions extends HandlerOptions {
+    winstonLogger: any;
+}
+/**
+ * Adapter for Winston
+ *
+ * @memo Winston has its own formatter
+ * @link https://github.com/winstonjs/winston
+ */
+declare class WinstonAdapter extends AbstractHandler implements Handler {
+    private winstonLogger;
+    constructor(level: LogLevel | undefined, options: WinstonAdapterOptions);
+    setFormatter(_formatter: Formatter): void;
+    getFormatter(): Formatter | null;
+    handle(record: LogRecord): Promise<boolean>;
+}
+
+/**
+ * Define the environment
+ */
+declare enum Environment {
+    UNKNOWN = "unknown",
+    BROWSE = "browser",
+    NODE = "node"
+}
+declare function getEnvironment(): Environment;
+
+interface TelegramHandlerOptions extends HandlerOptions {
+    botToken: string;
+    chatId: string | number;
+    parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2';
+    disableNotification?: boolean;
+    disableWebPagePreview?: boolean;
+    useStyles?: boolean;
+    warnInBrowser?: boolean;
+}
+/**
+ * Telegram Handler
+ *
+ * Sends logs to Telegram chat.
+ * The browser displays a warning in the console.
+ * In Node.js, sends a message via the Telegram Bot API.
+ */
+declare class TelegramHandler extends AbstractHandler implements Handler {
+    protected botToken: string;
+    protected chatId: string | number;
+    protected parseMode: 'HTML' | 'Markdown' | 'MarkdownV2';
+    protected disableNotification: boolean;
+    protected disableWebPagePreview: boolean;
+    protected readonly environment: Environment;
+    protected warnInBrowser: boolean;
+    constructor(level: LogLevel | undefined, options: TelegramHandlerOptions);
+    /**
+     * @inheritDoc
+     */
+    handle(record: LogRecord): Promise<boolean>;
+    /**
+     * Processing in the browser
+     */
+    protected _handleInBrowser(_message: string, record: LogRecord): Promise<boolean>;
+    /**
+     * Processing in Node.js
+     */
+    protected _handleInNode(message: string, _record: LogRecord): Promise<boolean>;
+    /**
+     * Fallback processing for unknown environments
+     */
+    protected _handleFallback(message: string): Promise<boolean>;
+    updateSettings(options: Partial<TelegramHandlerOptions>): this;
+    /**
+     * Get current environment
+     */
+    getEnvironment(): Environment;
+    /**
+     * Check if the Telegram API is available
+     */
+    testConnection(): Promise<boolean>;
+}
+
+declare abstract class AbstractLogger implements LoggerInterface {
+    /**
+     * @inheritDoc
+     */
+    abstract log(_level: LogLevel, _message: string, _context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    debug(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    info(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    notice(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    warning(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    error(message: string, context: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    critical(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    alert(message: string, context?: Record<string, any>): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    emergency(message: string, context?: Record<string, any>): Promise<void>;
+}
+
+/**
+ * This Logger can be used to avoid conditional log calls.
+ *
+ * Logging should always be optional, and if no logger is provided to your
+ * library creating a NullLogger instance to have something to throw logs at
+ * is a good way to avoid littering your code with `if (this.logger) { }`
+ * blocks.
+ */
+declare class NullLogger extends AbstractLogger implements LoggerInterface {
+    static create(): NullLogger;
+    /**
+     * @inheritDoc
+     */
+    log(_level: LogLevel, _message: string, _context?: Record<string, any>): Promise<void>;
+}
+
+/**
+ * A logger created according to the principles of `Monolog`
+ *
+ * @link https://github.com/Seldaek/monolog
+ */
+declare class Logger extends AbstractLogger implements LoggerInterface {
+    private readonly channel;
+    private handlers;
+    private processors;
+    constructor(channel: string);
+    static create(channel: string): Logger;
+    pushHandler(handler: Handler): this;
+    popHandler(): Handler | null;
+    setHandlers(handlers: Handler[]): this;
+    pushProcessor(processor: Processor): this;
+    /**
+     * @inheritDoc
+     */
+    log(level: LogLevel, message: string, context?: Record<string, any>): Promise<void>;
+}
+
+declare class LoggerFactory {
+    static createNullLogger(): LoggerInterface;
+    static createForBrowser(channel: string, isDevMode?: boolean): LoggerInterface;
+    static createForBrowserDevelopment(channel: string, level?: LogLevel): LoggerInterface;
+    static createForBrowserProduction(channel: string, level?: LogLevel): LoggerInterface;
+    static forcedLog(logger: LoggerInterface, action: 'debug' | 'info' | 'notice' | 'warning' | 'error' | 'critical' | 'alert' | 'emergency', message: string, context: Record<string, any>): Promise<void>;
+}
+
+/**
+ * @deprecate This enum is deprecated and will be removed in version `2.0.0`
+ */
 declare enum LoggerType {
     desktop = "desktop",
     log = "log",
@@ -8,20 +506,69 @@ declare enum LoggerType {
     error = "error",
     trace = "trace"
 }
-declare class LoggerBrowser {
+/**
+ * LoggerBrowser
+ *
+ * @deprecate This class is deprecated and will be removed in version `2.0.0`
+ *   - use {@link Logger `Logger`}
+ *
+ * @removed 2.0.0
+ */
+declare class LoggerBrowser implements LoggerInterface {
     #private;
+    /**
+     * Create a LoggerBrowser instance
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *
+     * @removed 2.0.0
+     */
     static build(title: string, isDevelopment?: boolean): LoggerBrowser;
     private constructor();
-    setConfig(types: Record<string | LoggerType, boolean>): void;
-    enable(type: LoggerType): boolean;
-    disable(type: LoggerType): boolean;
-    isEnabled(type: LoggerType): boolean;
-    desktop(...params: any[]): void;
-    log(...params: any[]): void;
-    info(...params: any[]): void;
-    warn(...params: any[]): void;
-    error(...params: any[]): void;
-    trace(...params: any[]): void;
+    /**
+     * Set config
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *
+     * @removed 2.0.0
+     */
+    setConfig(_types: Record<string | LoggerType, boolean>): void;
+    /**
+     * Set enable
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *
+     * @removed 2.0.0
+     */
+    enable(_type: LoggerType): boolean;
+    /**
+     * Set disable
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *
+     * @removed 2.0.0
+     */
+    disable(_type: LoggerType): boolean;
+    /**
+     * Test is enable
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *
+     * @removed 2.0.0
+     */
+    isEnabled(_type: LoggerType): boolean;
+    desktop(...params: any[]): Promise<void>;
+    log(...params: any[]): Promise<void>;
+    info(...params: any[]): Promise<void>;
+    warn(...params: any[]): Promise<void>;
+    error(...params: any[]): Promise<void>;
+    trace(...params: any[]): Promise<void>;
+    debug(...params: any[]): Promise<void>;
+    notice(...params: any[]): Promise<void>;
+    warning(...params: any[]): Promise<void>;
+    critical(...params: any[]): Promise<void>;
+    alert(...params: any[]): Promise<void>;
+    emergency(...params: any[]): Promise<void>;
 }
 
 /**
@@ -120,7 +667,7 @@ declare class TypeManager {
     /**
      * Returns true if a value is not an empty string
      * @param value
-     * @returns {boolean}
+     * @returns {boolean} Returns true if a value is not an empty string
      */
     isStringFilled(value: any): value is string;
     /**
@@ -190,7 +737,7 @@ declare class TypeManager {
     /**
      * Returns true if a value is an array, and it has at least one element
      * @param value
-     * @returns {boolean}
+     * @returns {boolean} Returns true if a value is an array, and it has at least one element
      */
     isArrayFilled(value: any): value is any[];
     /**
@@ -369,11 +916,16 @@ declare class TextManager {
      * @param {string} dateString
      * @param {string} template
      * @param opts
-     * @returns {DateTime}
+     * @returns {DateTime} Convert string to DateTime from ISO 8601 or self template
      *
      * @link https://moment.github.io/luxon/#/parsing?id=parsing-technical-formats
      */
     toDateTime(dateString: string, template?: string, opts?: DateTimeOptions): DateTime;
+    /**
+     * Convert Date to Bitrix24 REST API FORMAT Y-m-d\TH:i:sP
+     * @param date
+     */
+    toB24Format(date: string | DateTime | Date): string;
     getDateForLog(): string;
     buildQueryString(params: any): string;
 }
@@ -435,7 +987,7 @@ interface IResult<T = any> {
      *
      * @returns The data stored in the result, if any.
      */
-    getData: () => T | null;
+    getData: () => T | null | undefined;
     /**
      * Adds an error message or Error object to the result.
      * @param error The error message or Error object to be added.
@@ -481,12 +1033,12 @@ interface IResult<T = any> {
  */
 declare class Result<T = any> implements IResult<T> {
     protected _errors: Map<string, Error>;
-    protected _data: T | null;
+    protected _data: T | null | undefined;
     constructor(data?: T);
     get isSuccess(): boolean;
     get errors(): Map<string, Error>;
-    setData(data: T | null): Result<T>;
-    getData(): T | null;
+    setData(data: T | null | undefined): Result<T>;
+    getData(): T | null | undefined;
     addError(error: Error | string, key?: string): Result<T>;
     addErrors(errors: (Error | string)[]): Result<T>;
     getErrors(): IterableIterator<Error>;
@@ -510,128 +1062,6 @@ declare class Result<T = any> implements IResult<T> {
     static fail<U>(error: Error | string, key?: string): Result<U>;
 }
 
-type PayloadTime = {
-    readonly start: number;
-    readonly finish: number;
-    readonly duration: number;
-    readonly processing: number;
-    readonly date_start: string;
-    readonly date_finish: string;
-};
-type GetPayload<P> = {
-    readonly result: P;
-    readonly time: PayloadTime;
-};
-type ListPayload<P> = {
-    readonly result: any | P[];
-    readonly error?: string;
-    readonly total: number;
-    readonly next?: number;
-    readonly time: PayloadTime;
-};
-type BatchPayload<C> = {
-    readonly result: {
-        readonly result: {
-            readonly [P in keyof C]?: C[P];
-        } | ReadonlyArray<C[keyof C]>;
-        readonly result_error: {
-            readonly [P in keyof C]?: string;
-        } | readonly string[];
-        readonly result_total: {
-            readonly [P in keyof C]?: number;
-        } | readonly number[];
-        readonly result_next: {
-            readonly [P in keyof C]?: number;
-        } | readonly number[];
-        readonly result_time: {
-            readonly [P in keyof C]?: PayloadTime;
-        } | readonly PayloadTime[];
-    };
-    readonly time: PayloadTime;
-};
-type Payload<P> = GetPayload<P> | ListPayload<P> | BatchPayload<P>;
-
-type AjaxQuery = Readonly<{
-    method: string;
-    params: Readonly<object>;
-    start: number;
-}>;
-type AjaxResultParams<T = unknown> = Readonly<{
-    error?: string | {
-        error: string;
-        error_description?: string;
-    };
-    error_description?: string;
-    result: T;
-    next?: NumberString;
-    total?: NumberString;
-    time: PayloadTime;
-}>;
-type AjaxResultOptions<T> = Readonly<{
-    answer: AjaxResultParams<T>;
-    query: AjaxQuery;
-    status: number;
-}>;
-/**
- * Result of request to Rest Api
- */
-declare class AjaxResult<T = unknown> extends Result<Payload<T>> implements IResult<Payload<T>> {
-    #private;
-    private readonly _status;
-    private readonly _query;
-    protected _data: AjaxResultParams<T>;
-    constructor(options: AjaxResultOptions<T>);
-    getData(): Payload<T>;
-    /**
-     * Alias for isMore
-     */
-    hasMore(): boolean;
-    isMore(): boolean;
-    getTotal(): number;
-    getStatus(): number;
-    getQuery(): Readonly<AjaxQuery>;
-    /**
-     * Alias for getNext
-     * @param http
-     */
-    fetchNext(http: TypeHttp): Promise<AjaxResult<T> | null>;
-    getNext(http: TypeHttp): Promise<AjaxResult<T> | false>;
-    setData(): never;
-}
-
-type TypeHttp = {
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
-    batch(calls: any[] | object, isHaltOnError: boolean, returnAjaxResult: boolean): Promise<Result>;
-    call(method: string, params: object, start: number): Promise<AjaxResult>;
-    setRestrictionManagerParams(params: TypeRestrictionManagerParams): void;
-    getRestrictionManagerParams(): TypeRestrictionManagerParams;
-    setLogTag(logTag?: string): void;
-    clearLogTag(): void;
-    /**
-     * On|Off warning about client-side query execution
-     * @param {boolean} value
-     * @param {string} message
-     */
-    setClientSideWarning(value: boolean, message: string): void;
-};
-interface IRequestIdGenerator {
-    getRequestId(): string;
-    getHeaderFieldName(): string;
-    getQueryStringParameterName(): string;
-    getQueryStringSdkParameterName(): string;
-}
-type TypeRestrictionManagerParams = {
-    sleep: number;
-    speed: number;
-    amount: number;
-};
-declare const RestrictionManagerParamsBase: TypeRestrictionManagerParams;
-/**
- * @todo Need test
- */
-declare const RestrictionManagerParamsForEnterprise: TypeRestrictionManagerParams;
-
 /**
  * Special cases of data passed to handlers
  * @todo add docs
@@ -798,232 +1228,1501 @@ declare enum TypeOption {
     StringVal = "string"
 }
 
-type TypeDescriptionError = {
-    readonly error: 'invalid_token' | 'expired_token' | string;
-    readonly error_description: string;
-};
-/**
- * Parameters for hook
- */
-type B24HookParams = {
-    /**
-     * https://your-bitrix-portal.bitrix24.com
-     */
-    b24Url: string;
-    userId: number;
-    secret: string;
-};
 /**
- * Parameters passed in the GET request from the B24 parent window to the application
+ * @todo docs
  */
-type B24FrameQueryParams = {
-    DOMAIN: string | null | undefined;
-    PROTOCOL: boolean | null | undefined;
-    LANG: string | null | undefined;
-    APP_SID: string | null | undefined;
-};
 /**
- * Parameters for application for OAuth
+ * Settings for operating limiting
  */
-type B24OAuthSecret = {
-    clientId: string;
-    clientSecret: string;
-};
+interface OperatingLimitConfig {
+    /**
+     * Operating limit time period in milliseconds
+     * Default: 10 minutes (600_000 ms)
+     */
+    windowMs: number;
+    /**
+     * Maximum total execution time (operating) in milliseconds
+     * Default: 480 seconds (480_000 ms)
+     * When calculating the operating limit, we will use 5 seconds less
+     * @see Http.getTimeToFree
+     */
+    limitMs: number;
+    /**
+     * Threshold for notifications about heavy queries (%)
+     */
+    heavyPercent: number;
+}
 /**
- * Parameters for OAuth
- * @memo We get from b24 event this data
+ * Adaptive pause settings
  */
-interface B24OAuthParams {
+interface AdaptiveConfig {
     /**
-     * @example '1xxxxx1694'
+     * Threshold for heavy queries (%)
+     * Default: 80% - this means that `operating >= 384`
+     * Specifies what % of `operatingLimit.limitMs` in `operating` should pause.
      */
-    applicationToken: string;
+    thresholdPercent: number;
     /**
-     * @example 1
+     * Pause multiplier
+     * Default: 0.01 - 0.002 will result in a 1.2-second pause with increasing load
+     * If: operating_reset_at > Date.now()
+     * Then: Pause = (operating_reset_at - Date.now()) * coefficient
+     * Otherwise: Pause = 7_000
+     * There's no point in specifying a value close to 1, as this will create unnecessary delays.
+     * In other words: if coefficient === 1, the pause will last until the blocking is unblocked, and our code hasn't yet reached the limits.
+     * It's important to understand that the goal of adaptive blocking is to smoothly reduce the 'operating' of heavy queries.
      */
-    userId: number;
+    coefficient: number;
     /**
-     * @example '3xx2030386cyy1b'
+     * Maximum pause (ms)
+     * Default: 7_000 ms
+     * Limits the maximum estimated pause time
      */
-    memberId: string;
+    maxDelay: number;
     /**
-     * @example '1xxxxx1694'
+     * Whether adaptive pause is enabled
+     * Default: true
      */
-    accessToken: string;
+    enabled: boolean;
+}
+/**
+ * Rate limiting settings (Leaky Bucket)
+ */
+interface RateLimitConfig {
     /**
-     * @example '0xxxx4e000011e700000001000000260dc83b47c40e9b5fd501093674c4f5'
+     * X - limit before blocking (bucket capacity)
+     * For standard plans: 50
+     * For Enterprise: 250
      */
-    refreshToken: string;
+    burstLimit: number;
     /**
-     * @example 1745997853
+     * Y - leak rate (requests per second)
+     * For standard plans: 2
+     * For Enterprise: 5
      */
-    expires: number;
+    drainRate: number;
     /**
-     * @example 3600
+     * Whether adaptive control is enabled
+     * Default: true
      */
-    expiresIn: number;
+    adaptiveEnabled: boolean;
+}
+/**
+ * Parameters for managing all types of restrictions
+ */
+interface RestrictionParams {
+    rateLimit?: RateLimitConfig;
+    operatingLimit?: OperatingLimitConfig;
+    adaptiveConfig?: AdaptiveConfig;
     /**
-     * @example 'crm,catalog,bizproc,placement,user_brief'
+     * Maximum number of retries
+     * Default: 3
      */
-    scope: string;
+    maxRetries?: number;
     /**
-     * @example 'xxx.bitrix24.com'
+     * Base delay between retries (ms)
+     * Default: 1_000
      */
-    domain: string;
+    retryDelay?: number;
+}
+/**
+ * Limiter operation statistics
+ */
+interface RestrictionManagerStats {
+    /** Retries */
+    retries: number;
+    /** Consecutive errors */
+    consecutiveErrors: number;
+    /** Limit hits */
+    limitHits: number;
+    /** Current number of tokens */
+    tokens: number;
+    /** Adaptive delays */
+    adaptiveDelays: number;
+    /** Total time of adaptive delays */
+    totalAdaptiveDelay: number;
+    /** Heavy requests */
+    heavyRequestCount: number;
+    /** Method statistics in seconds */
+    operatingStats: {
+        [method: string]: number;
+    };
+}
+interface ILimiter {
+    getTitle(): string;
+    setConfig(config: any): Promise<void>;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    canProceed(requestId: string, method: string, params?: any): Promise<boolean>;
+    waitIfNeeded(requestId: string, method: string, params?: any): Promise<number>;
+    updateStats(requestId: string, method: string, data: any): Promise<void>;
+    reset(): Promise<void>;
+    getStats(): Record<string, any>;
+}
+
+/**
+ * Abstract Class for working with actions
+ */
+type ActionOptions = {
+    [key: string]: any;
+};
+declare abstract class AbstractAction {
+    protected _b24: TypeB24;
+    protected _logger: LoggerInterface;
+    constructor(b24: TypeB24, logger: LoggerInterface);
+    abstract make(options?: ActionOptions): AsyncGenerator | Promise<unknown>;
+}
+
+type ActionCallV2 = ActionOptions & {
+    method: string;
+    params?: TypeCallParams;
+    requestId?: string;
+};
+/**
+ * Calls the Bitrix24 REST API method `restApi:v2`
+ *
+ * @todo add docs
+ */
+declare class CallV2 extends AbstractAction {
     /**
-     * @example 'https://xxx.bitrix24.com/rest/'
+     * Calls the Bitrix24 REST API method.
+     *
+     * @template T - The expected data type in the response (default is `unknown`).
+     *
+     * @param {ActionCallV2} options - parameters for executing the request.
+     *     - `method: string` - REST API method name (eg: `crm.item.get`)
+     *     - `params?: TypeCallParams` - Parameters for calling the method.
+     *     - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging.
+     *
+     * @returns {Promise<AjaxResult<T>>} A promise that resolves to the result of an REST API call.
+     *
+     * @example
+     * import { EnumCrmEntityTypeId } from '@bitrix24/b24jssdk'
+     *
+     * interface CrmItem { id: number, name: string, lastName: string }
+     * const response = await b24.actions.v2.call.make<{ item: CrmItem }>({
+     *   method: 'crm.item.get',
+     *   params: {
+     *     entityTypeId: EnumCrmEntityTypeId.contact,
+     *     id: 123
+     *   },
+     *   requestId: 'item-123'
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     * console.log(response.getData().result.item.name)
+     */
+    make<T = unknown>(options: ActionCallV2): Promise<AjaxResult<T>>;
+}
+
+type ActionCallListV2 = ActionOptions & {
+    method: string;
+    params?: Omit<TypeCallParams, 'start'>;
+    idKey?: string;
+    customKeyForResult?: string;
+    requestId?: string;
+};
+/**
+ * Fast data retrieval without counting the total number of records. `restApi:v2`
+ *
+ * @todo add docs
+ */
+declare class CallListV2 extends AbstractAction {
+    /**
+     * Fast data retrieval without counting the total number of records.
+     *
+     * @template T - The type of the elements of the returned array (default is `unknown`).
+     *
+     * @param {ActionCallListV2} options - parameters for executing the request.
+     *     - `method: string` - The name of the REST API method that returns a list of data (for example: `crm.item.list`, `tasks.task.list`)
+     *     - `params?: Omit<TypeCallParams, 'start'>` - Request parameters, excluding the `start` parameter,
+     *         since the method is designed to obtain all data in one call.
+     *         Note: Use `filter`, `order`, and `select` to control the selection.
+     *     - `idKey?: string` - The name of the field containing the unique identifier of the element.
+     *         Default is 'ID' (uppercase). Alternatively, it can be 'id' (lowercase).
+     *         or another field, depending on the REST API data structure.
+     *     - `customKeyForResult?: string` - A custom key indicating that the response REST API will be
+     *        grouped by this field.
+     *        Example: `items` to group a list of CRM items.
+     *    - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging.
+     *
+     * @returns {Promise<Result<T[]>>} A promise that resolves to the result of an REST API call.
+     *
+     * @example
+     * import { EnumCrmEntityTypeId, Text } from '@bitrix24/b24jssdk'
+     *
+     * interface CrmItem { id: number, title: string }
+     * const sixMonthAgo = new Date()
+     * sixMonthAgo.setMonth((new Date()).getMonth() - 6)
+     * sixMonthAgo.setHours(0, 0, 0)
+     * const response = await b24.actions.v2.callList.make<CrmItem>({
+     *   method: 'crm.item.list',
+     *   params: {
+     *     entityTypeId:  EnumCrmEntityTypeId.company,
+     *     filter: {
+     *       '=%title': 'A%',
+     *       '>=createdTime': Text.toB24Format(sixMonthAgo) // created at least 6 months ago
+     *     },
+     *     select: ['id', 'title']
+     *   },
+     *   idKey: 'id',
+     *   customKeyForResult: 'items',
+     *   requestId: 'list-123'
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     * const list = response.getData()
+     * console.log(`Result: ${list?.length}`) // Number of items received
+     */
+    make<T = unknown>(options: ActionCallListV2): Promise<Result<T[]>>;
+}
+
+type ActionFetchListV2 = ActionOptions & {
+    method: string;
+    params?: Omit<TypeCallParams, 'start'>;
+    idKey?: string;
+    customKeyForResult?: string;
+    requestId?: string;
+};
+/**
+ * Calls a REST API list method and returns an async generator for efficient large data retrieval. `restApi:v2`
+ *
+ * @todo add docs
+ */
+declare class FetchListV2 extends AbstractAction {
+    /**
+     * Calls a REST API list method and returns an async generator for efficient large data retrieval.
+     * Implements the fast algorithm for iterating over large datasets without loading all data into memory at once.
+     *
+     * @template T - The type of items in the returned arrays (default is `unknown`).
+     *
+     * @param {ActionFetchListV2} options - parameters for executing the request.
+     *     - `method: string` - The name of the REST API method that returns a list of data (for example: `crm.item.list`, `tasks.task.list`)
+     *     - `params?: Omit<TypeCallParams, 'start'>` - Request parameters, excluding the `start` parameter,
+     *         since the method is designed to obtain all data in one call.
+     *         Note: Use `filter`, `order`, and `select` to control the selection.
+     *     - `idKey?: string` - The name of the field containing the unique identifier of the element.
+     *         Default is 'ID' (uppercase). Alternatively, it can be 'id' (lowercase).
+     *         or another field, depending on the REST API data structure.
+     *     - `customKeyForResult?: string` - A custom key indicating that the response REST API will be
+     *        grouped by this field.
+     *        Example: `items` to group a list of CRM items.
+     *    - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging.
+     *
+     * @returns {AsyncGenerator<T[]>} An async generator that yields chunks of data as arrays of type `T`.
+     *     Each iteration returns the next page/batch of results until all data is fetched.
+     *
+     * @example
+     * import { EnumCrmEntityTypeId, Text } from '@bitrix24/b24jssdk'
+     *
+     * interface CrmItem { id: number, title: string }
+     * const sixMonthAgo = new Date()
+     * sixMonthAgo.setMonth((new Date()).getMonth() - 6)
+     * sixMonthAgo.setHours(0, 0, 0)
+     * const generator = b24.actions.v2.fetchList.make<CrmItem>({
+     *   method: 'crm.item.list',
+     *   params: {
+     *     entityTypeId: EnumCrmEntityTypeId.company,
+     *     filter: {
+     *       '=%title': 'A%',
+     *       '>=createdTime': Text.toB24Format(sixMonthAgo) // created at least 6 months ago
+     *     },
+     *     select: ['id', 'title']
+     *   },
+     *   idKey: 'id',
+     *   customKeyForResult: 'items',
+     *   requestId: 'list-123'
+     * })
+     *
+     * for await (const chunk of generator) {
+     *   // Process chunk (e.g., save to database, analyze, etc.)
+     *   console.log(`Processing ${chunk.length} items`)
+     * }
+     *
+     * @see {@link https://apidocs.bitrix24.com/settings/performance/huge-data.html Bitrix24: Fast algorithm for large data}
      */
-    clientEndpoint: string;
+    make<T = unknown>(options: ActionFetchListV2): AsyncGenerator<T[]>;
+}
+
+declare abstract class AbstractBatch extends AbstractAction {
+    protected _addBatchErrorsIfAny(response: Result<ICallBatchResult<any>>, result: Result): void;
+    protected _processBatchResponse<T>(response: Result<ICallBatchResult<T>>, calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal, options: IB24BatchOptions): CallBatchResult<T>;
+    protected _createBatchResultWithAjax<T>(response: Result<ICallBatchResult<T>>, isArrayCall: boolean): CallBatchResult<T>;
+    protected _createBatchArrayResult<T>(response: Result<ICallBatchResult<T>>): Result<AjaxResult<T>[]>;
+    protected _createBatchObjectResult<T>(response: Result<ICallBatchResult<T>>): Result<Record<string | number, AjaxResult<T>>>;
+    protected _createBatchResultSimple<T>(response: Result<ICallBatchResult<T>>, isArrayCall: boolean): CallBatchResult<T>;
+    protected _extractBatchSimpleData<T>(response: Result<ICallBatchResult<T>>, isArrayCall: boolean): T;
+    chunkArray<T = unknown>(array: Array<T>, chunkSize?: number): T[][];
+}
+
+type ActionBatchV2 = ActionOptions & {
+    calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal;
+    options?: IB24BatchOptions;
+};
+/**
+ * Executes a batch request to the Bitrix24 REST API with a maximum number of commands of no more than 50. `restApi:v2`
+ * Allows you to execute multiple requests in a single API call, significantly improving performance.
+ *
+ * @todo add docs
+ */
+declare class BatchV2 extends AbstractBatch {
     /**
-     * @example 'https://oauth.bitrix.info/rest/'
+     * Executes a batch request to the Bitrix24 REST API with a maximum number of commands of no more than 50.
+     * Allows you to execute multiple requests in a single API call, significantly improving performance.
+     *
+     * @template T - The data type returned by batch query commands (default is `unknown`)
+     *
+     * @param {ActionBatchV2} options - parameters for executing the request.
+     *     - `calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal` - Commands to execute in a batch.
+     *        Supports several formats:
+     *        1. Array of tuples: `[['method1', params1], ['method2', params2], ...]`
+     *        2. Array of objects: `[{ method: 'method1', params: params1 }, { method: 'method2', params: params2 }, ...]`
+     *        3. An object with named commands: `{ cmd1: { method: 'method1', params: params1 }, cmd2: ['method2', params2], ...}`
+     *     - `options?: IB24BatchOptions` - Additional options for executing a batch request.
+     *        - `isHaltOnError?: boolean` - Whether to stop execution on the first error (default: true)
+     *        - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging (default: undefined)
+     *        - `returnAjaxResult?: boolean` - Whether to return an AjaxResult object instead of data (default: false)
+     *
+     * @returns {Promise<CallBatchResult<T>>} A promise that is resolved by the result of executing a batch request:
+     *     - On success: a `Result` object with the command execution results
+     *     - The structure of the results depends on the format of the `calls` input data:
+     *          - For an array of commands, an array of results in the same order
+     *          - For named commands, an object with keys corresponding to the command names
+     *
+     * @example
+     * import { EnumCrmEntityTypeId } from '@bitrix24/b24jssdk'
+     *
+     * interface Contact { id: number, name: string }
+     * const response = await b24.actions.v2.batch.make<{ item: Contact }>({
+     *   calls: [
+     *     ['crm.item.get', { entityTypeId: EnumCrmEntityTypeId.contact, id: 1 }],
+     *     ['crm.item.get', { entityTypeId: EnumCrmEntityTypeId.contact, id: 2 }],
+     *     ['crm.item.get', { entityTypeId: EnumCrmEntityTypeId.contact, id: 3 }]
+     *   ],
+     *   options: {
+     *     isHaltOnError: true,
+     *     returnAjaxResult: true,
+     *     requestId: 'batch-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * const resultData = (response as Result<AjaxResult<{ item: Contact }>[]>).getData()
+     * resultData.forEach((resultRow, index) => {
+     *   if (resultRow.isSuccess) {
+     *    console.log(`Item ${index + 1}:`, resultRow.getData().result.item)
+     *   }
+     * })
+     *
+     * @example
+     * import { EnumCrmEntityTypeId } from '@bitrix24/b24jssdk'
+     *
+     * const response = await b24.actions.v2.batch.make({
+     *   calls: [
+     *     { method: 'crm.item.get', params: { entityTypeId: EnumCrmEntityTypeId.contact, id: 1 } },
+     *     { method: 'crm.item.get', params: { entityTypeId: EnumCrmEntityTypeId.contact, id: 2 } }
+     *   ],
+     *   options: {
+     *     isHaltOnError: true,
+     *     returnAjaxResult: true,
+     *     requestId: 'batch-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * @example
+     * import { EnumCrmEntityTypeId } from '@bitrix24/b24jssdk'
+     *
+     * interface Contact { id: number, name: string }
+     * interface Deal { id: number, title: string }
+     * const response = await b24.actions.v2.batch.make<{ item: Contact } | { item: Deal }>({
+     *   calls: {
+     *     Contact: { method: 'crm.item.get', params: { entityTypeId: EnumCrmEntityTypeId.contact, id: 1 } },
+     *     Deal: ['crm.item.get', { entityTypeId: EnumCrmEntityTypeId.deal, id: 2 }]
+     *   },
+     *   options: {
+     *     isHaltOnError: true,
+     *     returnAjaxResult: true,
+     *     requestId: 'batch-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * const results = response.getData() as Record<string, AjaxResult<{ item: Contact } | { item: Deal }>>
+     * console.log('Contact:', results.Contact.getData().result.item as Contact)
+     * console.log('Deal:', results.Deal.getData().result.item as Deal)
+     *
+     * @warning The maximum number of commands in one batch request is 50.
+     * @note A batch request executes faster than sequential single calls,
+     *     but if one command fails, the entire batch may fail
+     *     (depending on API settings and options).
      */
-    serverEndpoint: string;
+    make<T = unknown>(options: ActionBatchV2): Promise<CallBatchResult<T>>;
+}
+
+type ActionBatchByChunkV2 = ActionOptions & {
+    calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal;
+    options?: Omit<IB24BatchOptions, 'returnAjaxResult'>;
+};
+/**
+ * Executes a batch request with automatic chunking for any number of commands. `restApi:v2`
+ *
+ * @todo add docs
+ */
+declare class BatchByChunkV2 extends AbstractBatch {
+    /**
+     * Executes a batch request with automatic chunking for any number of commands.
+     * Unlike `BatchV2`, which is limited to 50 commands, this method automatically splits
+     * a large set of commands into multiple batches and executes them sequentially.
+     *
+     * @template T - The data type returned by commands (default: `unknown`)
+     *
+     * @param {ActionBatchByChunkV2} options - parameters for executing the request.
+     *     - `calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal` - Commands to execute in a batch.
+     *        Supports several formats:
+     *        1. Array of tuples: `[['method1', params1], ['method2', params2], ...]`
+     *        2. Array of objects: `[{ method: 'method1', params: params1 }, { method: 'method2', params: params2 }, ...]`
+     *        - Note: Named commands are not supported as they are difficult to process when chunking.
+     *     - `options?: Omit<IB24BatchOptions, 'returnAjaxResult'>` - Additional options for executing a batch request.
+     *        - `isHaltOnError?: boolean` - Whether to stop execution on the first error (default: true)
+     *        - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging (default: undefined)
+     *
+     * @returns {Promise<Result<T[]>>} A promise that is resolved by the result of executing all commands.
+     *
+     * @example
+     * import { EnumCrmEntityTypeId, Text } from '@bitrix24/b24jssdk'
+     *
+     * interface Contact { id: number, name: string }
+     * const commands = Array.from({ length: 150 }, (_, i) =>
+     *   ['crm.item.get', { entityTypeId: EnumCrmEntityTypeId.contact, id: i + 1 }]
+     * )
+     *
+     * const response = await b24.actions.v2.batchByChunk.make<{ item: Contact }>({
+     *   calls: commands,
+     *   options: {
+     *     isHaltOnError: false,
+     *     requestId: 'batch-by-chunk-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * const resultData = response.getData()
+     * const items: Contact[] = []
+     * resultData.forEach((chunkRow) => {
+     *   items.push(chunkRow.item)
+     * })
+     * console.log(`Successfully retrieved ${items.length} items`)
+     *
+     * @tip For very large command sets, consider using server-side task queues instead of bulk batch requests.
+     */
+    make<T = unknown>(options: ActionBatchByChunkV2): Promise<Result<T[]>>;
+}
+
+/**
+ * Some actions for TypeB24 by Api:v2
+ */
+declare class ActionsManagerV2 {
+    protected _b24: TypeB24;
+    protected _logger: LoggerInterface;
+    protected _mapActions: Map<symbol, AbstractAction>;
+    constructor(b24: TypeB24);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    get call(): CallV2;
+    get callList(): CallListV2;
+    get fetchList(): FetchListV2;
+    get batch(): BatchV2;
+    get batchByChunk(): BatchByChunkV2;
+}
+
+type ActionCallV3 = ActionOptions & {
+    method: string;
+    params?: TypeCallParams;
+    requestId?: string;
+};
+/**
+ * Calls the Bitrix24 REST API method `restApi:v3`
+ *
+ * @todo add docs
+ */
+declare class CallV3 extends AbstractAction {
+    /**
+     * Calls the Bitrix24 REST API method.
+     *
+     * @template T - The expected data type in the response (default is `unknown`).
+     *
+     * @param {ActionCallV3} options - parameters for executing the request.
+     *     - `method: string` - REST API method name (eg: `crm.item.get`)
+     *     - `params?: TypeCallParams` - Parameters for calling the method.
+     *     - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging.
+     *
+     * @returns {Promise<AjaxResult<T>>} A promise that resolves to the result of an REST API call.
+     *
+     * @example
+     * interface TaskItem { id: number, title: string }
+     * const response = await b24.actions.v3.call.make<{ item: TaskItem }>({
+     *   method: 'tasks.task.get',
+     *   params: { id: 123, select: ['id', 'title'] },
+     *   requestId: 'task-123'
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     * console.log(response.getData().result.item.title)
+     */
+    make<T = unknown>(options: ActionCallV3): Promise<AjaxResult<T>>;
+}
+
+type ActionCallListV3 = ActionOptions & {
+    method: string;
+    params?: Omit<TypeCallParams, 'pagination'>;
+    idKey?: string;
+    customKeyForResult: string;
+    requestId?: string;
+    limit?: number;
+};
+/**
+ * Fast data retrieval without counting the total number of records. `restApi:v3`
+ *
+ * @todo add docs
+ */
+declare class CallListV3 extends AbstractAction {
+    /**
+     * Fast data retrieval without counting the total number of records.
+     *
+     * @template T - The type of the elements of the returned array (default is `unknown`).
+     *
+     * @param {ActionCallListV3} options - parameters for executing the request.
+     *     - `method: string` - The name of the REST API method that returns a list of data (for example: `crm.item.list`, `tasks.task.list`)
+     *     - `params?: Omit<TypeCallParams, 'pagination'>` - Request parameters, excluding the `pagination` parameter,
+     *         since the method is designed to obtain all data in one call.
+     *         Note: Use `filter`, `order`, and `select` to control the selection.
+     *     - `idKey?: string` - The name of the field containing the unique identifier of the element.
+     *         Default is 'id'. Alternatively, it can be another field, depending on the REST API data structure.
+     *     - `customKeyForResult: string` - A custom key indicating that the response REST API will be
+     *        grouped by this field.
+     *        Example: `items` to group a list of CRM items.
+     *    - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging.
+     *    - `limit?: number` - How many records to retrieve at a time. Default is `50`. Maximum is `1000`.
+     *
+     * @returns {Promise<Result<T[]>>} A promise that resolves to the result of an REST API call.
+     *
+     * @example
+     * import { Text } from '@bitrix24/b24jssdk'
+     *
+     * interface MainEventLogItem { id: number, userId: number }
+     * const sixMonthAgo = new Date()
+     * sixMonthAgo.setMonth((new Date()).getMonth() - 6)
+     * sixMonthAgo.setHours(0, 0, 0)
+     * const response = await b24.actions.v3.callList.make<MainEventLogItem>({
+     *   method: 'main.eventlog.list',
+     *   params: {
+     *     filter: [
+     *       ['timestampX', '>=', Text.toB24Format(sixMonthAgo)] // created at least 6 months ago
+     *     ],
+     *     select: ['id', 'userId']
+     *   },
+     *   idKey: 'id',
+     *   customKeyForResult: 'items',
+     *   requestId: 'eventlog-123',
+     *   limit: 60
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     * const list = response.getData()
+     * console.log(`Result: ${list?.length}`) // Number of items received
+     */
+    make<T = unknown>(options: ActionCallListV3): Promise<Result<T[]>>;
+}
+
+type ActionFetchListV3 = ActionOptions & {
+    method: string;
+    params?: Omit<TypeCallParams, 'pagination'>;
+    idKey?: string;
+    customKeyForResult: string;
+    requestId?: string;
+    limit?: number;
+};
+/**
+ * Calls a REST API list method and returns an async generator for efficient large data retrieval. `restApi:v3`
+ *
+ * @todo add docs
+ */
+declare class FetchListV3 extends AbstractAction {
+    /**
+     * Calls a REST API list method and returns an async generator for efficient large data retrieval.
+     * Implements the fast algorithm for iterating over large datasets without loading all data into memory at once.
+     *
+     * @template T - The type of items in the returned arrays (default is `unknown`).
+     *
+     * @param {ActionFetchListV3} options - parameters for executing the request.
+     *     - `method: string` - The name of the REST API method that returns a list of data (for example: `crm.item.list`, `tasks.task.list`)
+     *     - `params?: Omit<TypeCallParams, 'pagination'>` - Request parameters, excluding the `pagination` parameter,
+     *         since the method is designed to obtain all data in one call.
+     *         Note: Use `filter`, `order`, and `select` to control the selection.
+     *     - `idKey?: string` - The name of the field containing the unique identifier of the element.
+     *         Default is 'id'. Alternatively, it can be another field, depending on the REST API data structure.
+     *     - `customKeyForResult: string` - A custom key indicating that the response REST API will be
+     *        grouped by this field.
+     *        Example: `items` to group a list of CRM items.
+     *    - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging.
+     *    - `limit?: number` - How many records to retrieve at a time. Default is `50`. Maximum is `1000`.
+     *
+     * @returns {AsyncGenerator<T[]>} An async generator that yields chunks of data as arrays of type `T`.
+     *     Each iteration returns the next page/batch of results until all data is fetched.
+     *
+     * @example
+     * import { Text } from '@bitrix24/b24jssdk'
+     *
+     * interface MainEventLogItem { id: number, userId: number }
+     * const sixMonthAgo = new Date()
+     * sixMonthAgo.setMonth((new Date()).getMonth() - 6)
+     * sixMonthAgo.setHours(0, 0, 0)
+     * const generator = b24.actions.v3.fetchList.make<MainEventLogItem>({
+     *   method: 'main.eventlog.list',
+     *   params: {
+     *     filter: [
+     *      ['timestampX', '>=', Text.toB24Format(sixMonthAgo)] // created at least 6 months ago
+     *     ],
+     *     select: ['id', 'userId']
+     *   },
+     *   idKey: 'id',
+     *   customKeyForResult: 'items',
+     *   requestId: 'eventlog-123',
+     *   limit: 60
+     * })
+     * for await (const chunk of generator) {
+     *   // Process chunk (e.g., save to database, analyze, etc.)
+     *   console.log(`Processing ${chunk.length} items`)
+     * }
+     */
+    make<T = unknown>(options: ActionFetchListV3): AsyncGenerator<T[]>;
+}
+
+type ActionBatchV3 = ActionOptions & {
+    calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal;
+    options?: IB24BatchOptions;
+};
+/**
+ * Executes a batch request to the Bitrix24 REST API with a maximum number of commands of no more than 50. `restApi:v3`
+ * Allows you to execute multiple requests in a single API call, significantly improving performance.
+ *
+ * @todo add docs
+ */
+declare class BatchV3 extends AbstractBatch {
+    /**
+     * Executes a batch request to the Bitrix24 REST API with a maximum number of commands of no more than 50.
+     * Allows you to execute multiple requests in a single API call, significantly improving performance.
+     *
+     * @template T - The data type returned by batch query commands (default is `unknown`)
+     *
+     * @param {ActionBatchV3} options - parameters for executing the request.
+     *     - `calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal` - Commands to execute in a batch.
+     *        Supports several formats:
+     *        1. Array of tuples: `[['method1', params1], ['method2', params2], ...]`
+     *        2. Array of objects: `[{ method: 'method1', params: params1 }, { method: 'method2', params: params2 }, ...]`
+     *        3. An object with named commands: `{ cmd1: { method: 'method1', params: params1 }, cmd2: ['method2', params2], ...}`
+     *     - `options?: IB24BatchOptions` - Additional options for executing a batch request.
+     *        - `isHaltOnError?: boolean` - Whether to stop execution on the first error (default: true)
+     *        - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging (default: undefined)
+     *        - `returnAjaxResult?: boolean` - Whether to return an AjaxResult object instead of data (default: false)
+     *
+     * @returns {Promise<CallBatchResult<T>>} A promise that is resolved by the result of executing a batch request:
+     *     - On success: a `Result` object with the command execution results
+     *     - The structure of the results depends on the format of the `calls` input data:
+     *          - For an array of commands, an array of results in the same order
+     *          - For named commands, an object with keys corresponding to the command names
+     *
+     * @example
+     * interface TaskItem { id: number, title: string }
+     * const response = await b24.actions.v3.batch.make<{ item: TaskItem }>({
+     *   calls: [
+     *     ['tasks.task.get', { id: 1, select: ['id', 'title'] }],
+     *     ['tasks.task.get', { id: 2, select: ['id', 'title'] }],
+     *     ['tasks.task.get', { id: 3, select: ['id', 'title'] }]
+     *   ],
+     *   options: {
+     *     isHaltOnError: true,
+     *     returnAjaxResult: true,
+     *     requestId: 'batch-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * const resultData = (response as Result<AjaxResult<{ item: TaskItem }>[]>).getData()
+     * resultData.forEach((resultRow, index) => {
+     *   if (resultRow.isSuccess) {
+     *    console.log(`Item ${index + 1}:`, resultRow.getData().result.item)
+     *   }
+     * })
+     *
+     * @example
+     * const response = await b24.actions.v3.batch.make({
+     *   calls: [
+     *     { method: 'tasks.task.get', params: { id: 1, select: ['id', 'title'] } },
+     *     { method: 'tasks.task.get', params: { id: 2, select: ['id', 'title'] } }
+     *   ],
+     *   options: {
+     *     isHaltOnError: true,
+     *     returnAjaxResult: true,
+     *     requestId: 'batch-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * @example
+     * interface TaskItem { id: number, title: string }
+     * interface MainEventLogItem { id: number, userId: number }
+     * const response = await b24.actions.v3.batch.make<{ item: TaskItem } | { items: MainEventLogItem[] }>({
+     *   calls: {
+     *     Task: { method: 'tasks.task.get', params: { id: 1, select: ['id', 'title'] } },
+     *     MainEventLog: ['main.eventlog.list', { select: ['id', 'userId'], pagination: { limit: 5 } }]
+     *   },
+     *   options: {
+     *     isHaltOnError: true,
+     *     returnAjaxResult: true,
+     *     requestId: 'batch-123'
+     *   }
+     * })
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * const results = response.getData() as Record<string, AjaxResult<{ item: TaskItem } | { items: MainEventLogItem[] }>>
+     * console.log('Task:', results.Task.getData().result.item as TaskItem)
+     * console.log('MainEventLog:', results.MainEventLog.getData().result.items as MainEventLogItem[])
+     *
+     * @warning The maximum number of commands in one batch request is 50.
+     * @note A batch request executes faster than sequential single calls,
+     *     but if one command fails, the entire batch may fail
+     *     (depending on API settings and options).
+     */
+    make<T = unknown>(options: ActionBatchV3): Promise<CallBatchResult<T>>;
+}
+
+type ActionBatchByChunkV3 = ActionOptions & {
+    calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal;
+    options?: Omit<IB24BatchOptions, 'returnAjaxResult'>;
+};
+/**
+ * Executes a batch request with automatic chunking for any number of commands. `restApi:v3`
+ *
+ * @todo add docs
+ * @todo test self
+ * @todo test example
+ */
+declare class BatchByChunkV3 extends AbstractBatch {
+    /**
+     * Executes a batch request with automatic chunking for any number of commands.
+     * Unlike `BatchV3`, which is limited to 50 commands, this method automatically splits
+     * a large set of commands into multiple batches and executes them sequentially.
+     *
+     * @template T - The data type returned by commands (default: `unknown`)
+     *
+     * @param {ActionBatchByChunkV3} options - parameters for executing the request.
+     *     - `calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal` - Commands to execute in a batch.
+     *        Supports several formats:
+     *        1. Array of tuples: `[['method1', params1], ['method2', params2], ...]`
+     *        2. Array of objects: `[{ method: 'method1', params: params1 }, { method: 'method2', params: params2 }, ...]`
+     *        - Note: Named commands are not supported as they are difficult to process when chunking.
+     *     - `options?: Omit<IB24BatchOptions, 'returnAjaxResult'>` - Additional options for executing a batch request.
+     *        - `isHaltOnError?: boolean` - Whether to stop execution on the first error (default: true)
+     *        - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging (default: undefined)
+     *
+     * @returns {Promise<Result<T[]>>} A promise that is resolved by the result of executing all commands.
+     *
+     * @example
+     * interface TaskItem { id: number, title: string }
+     * const commands: BatchCommandsArrayUniversal = Array.from({ length: 150 }, (_, i) =>
+     *   ['tasks.task.get', { id: i + 1, select: ['id', 'title'] }]
+     * )
+     *
+     * const response = await b24.actions.v3.batchByChunk.make<{ item: TaskItem }>({
+     *   calls: commands,
+     *   options: {
+     *     isHaltOnError: false,
+     *     requestId: 'batch-by-chunk-123'
+     *   }
+     * })
+     *
+     * if (!response.isSuccess) {
+     *   throw new Error(`Problem: ${response.getErrorMessages().join('; ')}`)
+     * }
+     *
+     * const resultData = response.getData()
+     * const items: TaskItem[] = []
+     * resultData.forEach((chunkRow) => {
+     *   items.push(chunkRow.item)
+     * })
+     * console.log(`Successfully retrieved ${items.length} items`)
+     *
+     * @tip For very large command sets, consider using server-side task queues instead of bulk batch requests.
+     */
+    make<T = unknown>(options: ActionBatchByChunkV3): Promise<Result<T[]>>;
+}
+
+/**
+ * Some actions for TypeB24 by Api:v3
+ */
+declare class ActionsManagerV3 {
+    protected _b24: TypeB24;
+    protected _logger: LoggerInterface;
+    protected _mapActions: Map<symbol, AbstractAction>;
+    constructor(b24: TypeB24);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    get call(): CallV3;
+    get callList(): CallListV3;
+    get fetchList(): FetchListV3;
+    get batch(): BatchV3;
+    get batchByChunk(): BatchByChunkV3;
+}
+
+/**
+ * Some actions for TypeB24
+ */
+declare class ActionsManager {
+    protected _b24: TypeB24;
+    protected _logger: LoggerInterface;
+    protected _mapActions: Map<symbol, any>;
+    constructor(b24: TypeB24);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    get v2(): ActionsManagerV2;
+    get v3(): ActionsManagerV3;
+}
+
+/**
+ * Abstract Class for working with tools
+ */
+type ToolOptions = {
+    [key: string]: any;
+};
+declare abstract class AbstractTool {
+    protected _b24: TypeB24;
+    protected _logger: LoggerInterface;
+    constructor(b24: TypeB24, logger: LoggerInterface);
+    abstract make(options?: ToolOptions): Promise<unknown>;
+}
+
+/**
+ * Ping `restApi:v2`
+ *
+ * @todo use apiVer3
+ */
+declare class Ping extends AbstractTool {
+    /**
+     * Measures the response speed of the Bitrix24 REST API.
+     * Performs a test request and returns the response time in milliseconds.
+     * Useful for performance monitoring and diagnosing latency issues.
+     *
+     * @note The method uses a minimal API request (`server.time`) to check availability.
+     *   Does not overload the server with large amounts of data.
+     *
+     * @warning Response time may vary depending on server load, network conditions
+     *     and HTTP client settings (timeouts, retries).
+     *
+     * @tip For consistent results, it is recommended to perform multiple measurements
+     *     and use the median value.
+     *
+     * @param options Some options for executing
+     *   - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging (default: undefined)
+     *
+     * @returns {Promise<number>} Promise that resolves to a response time in milliseconds:
+     *   - Positive number: time from sending the request to receiving the response
+     *   - In case of an error or timeout: `-1`
+     *
+     * @see {@link HealthCheck} To check API availability
+     */
+    make(options?: ToolOptions & {
+        requestId?: string;
+    }): Promise<number>;
+}
+
+/**
+ * HealthCheck `restApi:v2`
+ *
+ * @todo use apiVer3
+ */
+declare class HealthCheck extends AbstractTool {
+    /**
+     * Checks the availability of the Bitrix24 REST API.
+     * Performs a simple request to the API to verify the service is operational and that the required access rights are present.
+     *
+     * @note The method uses a minimal API request (`server.time`) to check availability.
+     *   Does not overload the server with large amounts of data.
+     *
+     * @param options Some options for executing
+     *   - `requestId?: string` - Unique request identifier for tracking. Used for query deduplication and debugging (default: undefined)
+     *
+     * @returns {Promise<false>} Promise that resolves to a Boolean value:
+     *   - `true`: the API is available and responding
+     *   - `false`: the API is unavailable, an error occurred, or the required access rights are missing
+     *
+     * @see {@link Ping} To measure API response speed
+     */
+    make(options?: ToolOptions & {
+        requestId?: string;
+    }): Promise<boolean>;
+}
+
+/**
+ * Some tools for TypeB24
+ * @todo add docs
+ */
+declare class ToolsManager {
+    protected _b24: TypeB24;
+    protected _logger: LoggerInterface;
+    protected _mapTools: Map<symbol, AbstractTool>;
+    constructor(b24: TypeB24);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    get ping(): Ping;
+    get healthCheck(): HealthCheck;
+}
+
+/**
+ * @todo docs
+ */
+declare enum ApiVersion {
+    v3 = "v3",
+    v2 = "v2"
+}
+/**
+ * Options for batch calls
+ */
+interface IB24BatchOptions extends ICallBatchOptions {
+    /**
+     * Api Version
+     * If the option is empty, then automatic detection is performed using the specified methods.
+     */
+    apiVersion?: ApiVersion;
+    /**
+     * Whether to return an AjaxResult object instead of data
+     * @default false
+     */
+    returnAjaxResult?: boolean;
+}
+type CallBatchResult<T> = Result<Record<string | number, AjaxResult<T>>> | Result<AjaxResult<T>[]> | Result<T>;
+type TypeB24 = {
+    /**
+     * @see {https://bitrix24.github.io/b24jssdk/docs/hook/ Js SDK documentation}
+     * @see {https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-functions/bx24-init.html Bitrix24 REST API documentation}
+     */
+    readonly isInit: boolean;
+    init(): Promise<void>;
+    destroy(): void;
+    getLogger(): LoggerInterface;
+    setLogger(logger: LoggerInterface): void;
+    /**
+     * Returns the AuthActions interface for handling authorization.
+     */
+    get auth(): AuthActions;
+    /**
+     * Returns the ActionsManager interface for working with Bitrix24 methods. Dependent on the REST API version.
+     */
+    get actions(): ActionsManager;
+    /**
+     * Returns the ToolsManager interface for access to Bitrix24 utilities independent of the REST API version.
+     */
+    get tools(): ToolsManager;
+    /**
+     * Sets the restriction parameters
+     */
+    setRestrictionManagerParams(params: RestrictionParams): Promise<void>;
+    /**
+     * Get the account address Bitrix24 ( `https://your_domain.bitrix24.com` )
+     */
+    getTargetOrigin(): string;
+    /**
+     * Get the account address Bitrix24 with path
+     *  - `restApi:v3` `https://your_domain.bitrix24.com/rest/api/`
+     *  - `restApi:v2` `https://your_domain.bitrix24.com/rest/`
+     */
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
+    /**
+     * Calls the Bitrix24 REST API method.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link CallV3.make `b24.actions.v3.call.make(options)`}
+     *   - for `restApi:v2` use {@link CallV2.make `b24.actions.v2.call.make(options)`}
+     *
+     * @removed 2.0.0
+     */
+    callMethod(method: string, params?: object, start?: number): Promise<AjaxResult>;
+    /**
+     * Calls a Bitrix24 REST API list method to retrieve all data.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link CallListV3.make `b24.actions.v3.callList.make(options)`}
+     *   - for `restApi:v2` use {@link CallListV2.make `b24.actions.v2.callList.make(options)`}
+     *
+     * @removed 2.0.0
+     */
+    callListMethod(method: string, params?: object, progress?: null | ((progress: number) => void), customKeyForResult?: string | null): Promise<Result>;
+    /**
+     * Calls a Bitrix24 REST API list method and returns an async generator.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link FetchListV3.make `b24.actions.v3.fetchList.make(options)`}
+     *   - for `restApi:v2` use {@link FetchListV2.make `b24.actions.v2.fetchList.make(options)`}
+     *
+     * @removed 2.0.0
+     */
+    fetchListMethod(method: string, params?: any, idKey?: string, customKeyForResult?: string | null): AsyncGenerator<any[]>;
+    /**
+     * Executes a batch request to the Bitrix24 REST API
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link BatchV3.make `b24.actions.v3.batch.make(options)`}
+     *   - for `restApi:v2` use {@link BatchV2.make `b24.actions.v2.batch.make(options)`}
+     *
+     * @removed 2.0.0
+     */
+    callBatch(calls: Array<any> | object, isHaltOnError?: boolean, returnAjaxResult?: boolean): Promise<Result>;
+    /**
+     * Executes a batch request to the Bitrix24 REST API with automatic chunking for any number of commands.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link BatchByChunkV3.make `b24.actions.v3.batchByChunk.make(options)`}
+     *   - for `restApi:v2` use {@link BatchByChunkV2.make `b24.actions.v2.batchByChunk.make(options)`}
+     *
+     * @removed 2.0.0
+     */
+    callBatchByChunk(calls: Array<any>, isHaltOnError: boolean): Promise<Result>;
+    /**
+     * Returns the HTTP client to perform the request.
+     */
+    getHttpClient(version: ApiVersion): TypeHttp;
+    /**
+     * Set HTTP client
+     */
+    setHttpClient(version: ApiVersion, client: TypeHttp): void;
+};
+
+/**
+ * @link https://apidocs.bitrix24.com/api-reference/rest-v3/index.html#structure-of-an-unsuccessful-response
+ *
+ * @todo ! move to packages/jssdk/src/types/payloads.ts
+ */
+type TypeDescriptionErrorV3 = {
+    readonly error: {
+        code: string;
+        message: string;
+        validation?: {
+            message?: string;
+            field?: string;
+            [key: string]: any;
+        }[];
+    };
+};
+type TypeDescriptionError = {
+    readonly error: 'invalid_token' | 'expired_token' | string;
+    readonly error_description?: string;
+};
+/**
+ * Parameters for hook
+ */
+type B24HookParams = {
+    /**
+     * https://your-bitrix-portal.bitrix24.com
+     */
+    b24Url: string;
+    userId: number;
+    secret: string;
+};
+/**
+ * Parameters passed in the GET request from the B24 parent window to the application
+ */
+type B24FrameQueryParams = {
+    DOMAIN: string | null | undefined;
+    PROTOCOL: boolean | null | undefined;
+    LANG: string | null | undefined;
+    APP_SID: string | null | undefined;
+};
+/**
+ * Parameters for application for OAuth
+ */
+type B24OAuthSecret = {
+    clientId: string;
+    clientSecret: string;
+};
+/**
+ * Parameters for OAuth
+ * @memo We get from b24 event this data
+ */
+interface B24OAuthParams {
+    /**
+     * @example '1xxxxx1694'
+     */
+    applicationToken: string;
+    /**
+     * @example 1
+     */
+    userId: number;
+    /**
+     * @example '3xx2030386cyy1b'
+     */
+    memberId: string;
+    /**
+     * @example '1xxxxx1694'
+     */
+    accessToken: string;
+    /**
+     * @example '0xxxx4e000011e700000001000000260dc83b47c40e9b5fd501093674c4f5'
+     */
+    refreshToken: string;
+    /**
+     * @example 1745997853
+     */
+    expires: number;
+    /**
+     * @example 3600
+     */
+    expiresIn: number;
+    /**
+     * @example 'crm,catalog,bizproc,placement,user_brief'
+     */
+    scope: string;
+    /**
+     * @example 'xxx.bitrix24.com'
+     */
+    domain: string;
+    /**
+     * @example 'https://xxx.bitrix24.com/rest/'
+     */
+    clientEndpoint: string;
+    /**
+     * @example 'https://oauth.bitrix.info/rest/'
+     */
+    serverEndpoint: string;
+    /**
+     * @example 'L'
+     */
+    status: typeof EnumAppStatus[keyof typeof EnumAppStatus];
+    issuer?: 'request' | 'store' | string;
+}
+type HandlerRefreshAuth = Pick<HandlerAuthParams, 'access_token' | 'refresh_token' | 'expires' | 'expires_in' | 'client_endpoint' | 'server_endpoint' | 'member_id' | 'scope' | 'status' | 'domain'>;
+/**
+ * Callback called when OAuth authorization is updated
+ */
+type CallbackRefreshAuth = (params: {
+    authData: AuthData;
+    b24OAuthParams: B24OAuthParams;
+}) => Promise<void>;
+/**
+ * Use for custom get new refresh token for OAuth
+ */
+type CustomRefreshAuth = () => Promise<HandlerRefreshAuth>;
+/**
+ * Parameters passed from the parent window when calling refreshAuth
+ */
+type RefreshAuthData = {
+    AUTH_ID: string;
+    REFRESH_ID: string;
+    AUTH_EXPIRES: NumberString;
+};
+/**
+ * Parameters passed from the parent window when calling getInitData
+ */
+type MessageInitData = RefreshAuthData & {
+    DOMAIN: string;
+    PROTOCOL: string;
+    PATH: string;
+    LANG: string;
+    MEMBER_ID: string;
+    IS_ADMIN: boolean;
+    APP_OPTIONS: Record<string, any>;
+    USER_OPTIONS: Record<string, any>;
+    PLACEMENT: string;
+    PLACEMENT_OPTIONS: Record<string, any>;
+    INSTALL: boolean;
+    FIRST_RUN: boolean;
+};
+/**
+ * Parameters for OAuth authorization
+ */
+type AuthData = {
+    access_token: string;
+    refresh_token: string;
+    expires: number;
+    expires_in: number;
+    domain: string;
+    member_id: string;
+    [key: string]: any;
+};
+/**
+ * Interface for updating authorization
+ */
+interface AuthActions {
+    getAuthData: () => false | AuthData;
+    refreshAuth: () => Promise<AuthData>;
+    getUniq: (prefix: string) => string;
+    isAdmin: boolean;
+    /**
+     * Get the account address BX24 ( `https://your_domain.bitrix24.com` )
+     */
+    getTargetOrigin(): string;
+    /**
+     * Get the account address BX24 with path
+     *   - ver2 `https://your_domain.bitrix24.com/rest/`
+     *   - ver3` https://your_domain.bitrix24.com/rest/api/`
+     */
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
+}
+
+type PayloadTime = {
+    readonly start: number;
+    readonly finish: number;
+    readonly duration: number;
+    readonly processing: number;
+    readonly date_start: ISODate;
+    readonly date_finish: ISODate;
+    /**
+     * timestamp - when part of the limit for this method will be released.
+     */
+    readonly operating_reset_at: number;
+    /**
+     * indicates the execution time of a request to a specific method.
+     */
+    readonly operating: number;
+};
+type GetPayload<P> = {
+    readonly result: P;
+    readonly time: PayloadTime;
+};
+type ListPayload<P> = {
+    readonly result: any | P[];
+    readonly total: number;
+    readonly next?: number;
+    readonly time: PayloadTime;
+};
+type BatchPayloadResult<C> = {
+    readonly result: {
+        readonly [P in keyof C]?: C[P];
+    } | ReadonlyArray<C[keyof C]>;
+    readonly result_error: {
+        readonly [P in keyof C]?: string;
+    } | readonly string[];
+    readonly result_total: {
+        readonly [P in keyof C]?: number;
+    } | readonly number[];
+    readonly result_next: {
+        readonly [P in keyof C]?: number;
+    } | readonly number[];
+    readonly result_time: {
+        readonly [P in keyof C]?: PayloadTime;
+    } | readonly PayloadTime[];
+};
+type BatchPayload<C> = {
+    readonly result: BatchPayloadResult<C>;
+    readonly time: PayloadTime;
+};
+type Payload<P> = TypeDescriptionErrorV3 | TypeDescriptionError | GetPayload<P> | ListPayload<P> | BatchPayload<P>;
+type SuccessPayload<P> = Exclude<Payload<P>, TypeDescriptionErrorV3 | TypeDescriptionError>;
+
+type AjaxQuery = Readonly<{
+    method: string;
+    params: TypeCallParams;
+    requestId: string;
+}>;
+type AjaxResultOptions<T> = Readonly<{
+    answer: Payload<T>;
+    query: AjaxQuery;
+    status: number;
+}>;
+/**
+ * Result of request to Rest Api
+ *
+ * @todo docs
+ */
+declare class AjaxResult<T = unknown> extends Result<Payload<T>> implements IResult<Payload<T>> {
+    #private;
+    private readonly _status;
+    private readonly _query;
+    protected _data: Payload<T> | null | undefined;
+    constructor(options: AjaxResultOptions<T>);
+    get isSuccess(): boolean;
+    getData(): undefined | SuccessPayload<T>;
+    /**
+     * Alias for isMore
+     */
+    hasMore(): boolean;
+    isMore(): boolean;
+    getTotal(): number;
+    getStatus(): number;
+    getQuery(): Readonly<AjaxQuery>;
     /**
-     * @example 'L'
+     * Alias for getNext
+     * @param http
+     *
+     * @todo !fix api version
      */
-    status: typeof EnumAppStatus[keyof typeof EnumAppStatus];
-    issuer?: 'request' | 'store' | string;
+    fetchNext(http: TypeHttp): Promise<AjaxResult<T> | null>;
+    getNext(http: TypeHttp): Promise<AjaxResult<T> | false>;
+    setData(): never;
 }
-type HandlerRefreshAuth = Pick<HandlerAuthParams, 'access_token' | 'refresh_token' | 'expires' | 'expires_in' | 'client_endpoint' | 'server_endpoint' | 'member_id' | 'scope' | 'status' | 'domain'>;
+
 /**
- * Callback called when OAuth authorization is updated
+ * @todo fix docs
  */
-type CallbackRefreshAuth = (params: {
-    authData: AuthData;
-    b24OAuthParams: B24OAuthParams;
-}) => Promise<void>;
+type TypeCallParams = {
+    order?: Record<string, 'ASC' | 'DESC' | 'asc' | 'desc' | string>;
+    filter?: any;
+    select?: string[];
+    params?: any;
+    /**
+     * Used only in Api:V2
+     */
+    start?: number;
+    /**
+     * Used only in Api:V3
+     */
+    pagination?: {
+        limit?: number;
+        /**
+         * Minimum 1
+         */
+        page?: number;
+        /**
+         * You need to use either `page` or `offset`. There's no point in using both.
+         */
+        offset?: number;
+    };
+    /**
+     * Used only in Api:V3
+     */
+    cursor?: {
+        field: string;
+        value: number;
+        order: 'ASC' | 'DESC' | 'asc' | 'desc' | string;
+    };
+    [key: string]: any;
+};
 /**
- * Use for custom get new refresh token for OAuth
+ * Options for batch calls
  */
-type CustomRefreshAuth = () => Promise<HandlerRefreshAuth>;
+interface ICallBatchOptions {
+    /**
+     * Whether to stop execution on the first error
+     * @default true
+     */
+    isHaltOnError?: boolean;
+    /**
+     * Unique request identifier for tracking. Used for query deduplication and debugging.
+     */
+    requestId?: string;
+}
 /**
- * Parameters passed from the parent window when calling refreshAuth
+ * Result of the batch call
  */
-type RefreshAuthData = {
-    AUTH_ID: string;
-    REFRESH_ID: string;
-    AUTH_EXPIRES: NumberString;
+interface ICallBatchResult<T = unknown> {
+    result?: Map<string | number, AjaxResult<T>>;
+    time?: PayloadTime;
+}
+type BatchCommandV3 = {
+    method: string;
+    query?: Record<string, unknown>;
+    as?: string;
+    parallel?: boolean;
 };
+type CommandTuple<M extends string = string, P = undefined | TypeCallParams> = [M, P?];
 /**
- * Parameters passed from the parent window when calling getInitData
+ * @todo add docs - api v3 only use this ??
  */
-type MessageInitData = RefreshAuthData & {
-    DOMAIN: string;
-    PROTOCOL: string;
-    PATH: string;
-    LANG: string;
-    MEMBER_ID: string;
-    IS_ADMIN: boolean;
-    APP_OPTIONS: Record<string, any>;
-    USER_OPTIONS: Record<string, any>;
-    PLACEMENT: string;
-    PLACEMENT_OPTIONS: Record<string, any>;
-    INSTALL: boolean;
-    FIRST_RUN: boolean;
-};
+interface CommandObject<M extends string = string, P = undefined | TypeCallParams> {
+    method: M;
+    params?: P;
+    as?: string;
+    parallel?: boolean;
+}
+type CommandUniversal<M extends string = string, P = undefined | TypeCallParams> = CommandTuple<M, P> | CommandObject<M, P>;
+type BatchCommandsArrayUniversal<M extends string = string, P = undefined | TypeCallParams> = CommandTuple<M, P>[];
+type BatchCommandsObjectUniversal<M extends string = string, P = undefined | TypeCallParams> = CommandObject<M, P>[];
+type BatchNamedCommandsUniversal<K extends string | number | symbol = string, M extends string = string, P = undefined | TypeCallParams> = Record<K, CommandObject<M, P> | CommandTuple<M, P>>;
+type BatchCommandsUniversal<M extends string = string, P = undefined | TypeCallParams> = CommandUniversal<M, P>[];
 /**
- * Parameters for OAuth authorization
+ * Interface for Request id generator
  */
-type AuthData = {
-    access_token: string;
-    refresh_token: string;
-    expires_in: number;
-    domain: string;
-    member_id: string;
-};
+interface IRequestIdGenerator {
+    getRequestId(): string;
+    getHeaderFieldName(): string;
+    getQueryStringParameterName(): string;
+    getQueryStringSdkParameterName(): string;
+}
 /**
- * Interface for updating authorization
+ * Interface for HTTP client
  */
-interface AuthActions {
-    getAuthData: () => false | AuthData;
-    refreshAuth: () => Promise<AuthData>;
-    getUniq: (prefix: string) => string;
-    isAdmin: boolean;
-}
-
-type TypeB24 = {
-    /**
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-functions/bx24-init.html
-     */
-    readonly isInit: boolean;
-    init(): Promise<void>;
-    destroy(): void;
-    getLogger(): LoggerBrowser;
-    setLogger(logger: LoggerBrowser): void;
-    get auth(): AuthActions;
-    /**
-     * Get the account address BX24 ( https://name.bitrix24.com )
-     */
-    getTargetOrigin(): string;
+type TypeHttp = {
+    apiVersion: ApiVersion;
+    ajaxClient: AxiosInstance | any;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     /**
-     * Get the account address BX24 ( https://name.bitrix24.com/rest )
+     * Executing batch queries
      */
-    getTargetOriginWithPath(): string;
+    batch<T = unknown>(calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal, options?: ICallBatchOptions): Promise<Result<ICallBatchResult<T>>>;
     /**
-     * Calls a REST service method with the specified parameters
-     *
-     * @param {string} method
-     * @param {object} params
-     * @param {number} start
-     *
-     * @return {Promise}
-     *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/how-to-call-rest-methods/bx24-call-method.html
+     * Calling the RestApi function
+     * @param method - REST API method name
+     * @param params - Parameters for the method.
+     * @param requestId - Request id
+     * @returns Promise with AjaxResult
      */
-    callMethod(method: string, params?: object, start?: number): Promise<AjaxResult>;
+    call<T = unknown>(method: string, params: TypeCallParams, requestId?: string): Promise<AjaxResult<T>>;
     /**
-     * Calls a REST service list method with the specified parameters
-     *
-     * @param  {string} method Query method
-     * @param  {object} params Request parameters
-     * @param {null|((progress: number) => void)} progress Processing steps
-     * @param {string} customKeyForResult Custom field indicating that the result will be a grouping key
-     * @return {Promise}
+     * Sets the restriction parameters
      */
-    callListMethod(method: string, params?: object, progress?: null | ((progress: number) => void), customKeyForResult?: string | null): Promise<Result>;
+    setRestrictionManagerParams(params: RestrictionParams): Promise<void>;
     /**
-     * Calls a REST service list method with the specified parameters and returns a generator object.
-     * Implements the fast algorithm described in {@see https://apidocs.bitrix24.com/api-reference/performance/huge-data.html}
-     *
-     * @param {string} method Query method
-     * @param {object} params Request parameters
-     * @param {string} idKey Entity ID field name ('ID' || 'id')
-     * @param {string} customKeyForResult Custom field indicating that the result will be a grouping key
-     *
-     * @return {AsyncGenerator} Generator
+     * Returns the current constraint settings
      */
-    fetchListMethod(method: string, params?: any, idKey?: string, customKeyForResult?: string | null): AsyncGenerator<any[]>;
+    getRestrictionManagerParams(): RestrictionParams;
     /**
-     * Calls a batch request with a maximum number of commands of no more than 50
-     *
-     * @param  {array|object} calls Request packet
-     * calls = [[method,params],[method,params]]
-     * calls = [{method:method,params:params},[method,params]]
-     * calls = {call_id:[method,params],...}
-     * @param  {boolean} isHaltOnError Abort package execution when an error occurs
-     * @param  {boolean} returnAjaxResult Return `Record<string | number, AjaxResult> | AjaxResult[]` in response
-     *
-     * @return {Promise} Promise
-     *
-     * @see https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/how-to-call-rest-methods/bx24-call-batch.html
+     * Returns job statistics
      */
-    callBatch(calls: Array<any> | object, isHaltOnError?: boolean, returnAjaxResult?: boolean): Promise<Result>;
+    getStats(): RestrictionManagerStats & {
+        adaptiveDelayAvg: number;
+        errorCounts: Record<string, number>;
+        totalRequests: number;
+        successfulRequests: number;
+        failedRequests: number;
+        totalDuration: number;
+        byMethod: Map<string, {
+            count: number;
+            totalDuration: number;
+        }>;
+        lastErrors: {
+            method: string;
+            error: string;
+            timestamp: number;
+        }[];
+    };
     /**
-     * Calls a batch request with any number of commands
-     *
-     * @param  {array} calls Request packet
-     * calls = [[method,params],[method,params]]
-     * @param  {boolean} isHaltOnError Abort package execution when an error occurs
-     *
-     * @return {Promise} Promise
-     *
-     * @see https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/how-to-call-rest-methods/bx24-call-batch.html
+     * Resets limiters and statistics
      */
-    callBatchByChunk(calls: Array<any>, isHaltOnError: boolean): Promise<Result>;
+    reset(): Promise<void>;
     /**
-     * Returns Http client for requests
+     * On|Off warning about client-side query execution
+     * @param {boolean} value
+     * @param {string} message
      */
-    getHttpClient(): TypeHttp;
+    setClientSideWarning(value: boolean, message: string): void;
 };
 
 /**
@@ -1431,28 +3130,27 @@ interface IPlacementUF {
  * It is worth remembering that there will be 1-2 languages for the B24.Box
  */
 declare enum B24LangList {
-    en = "en",
+    ru = "ru",
+    id = "id",
+    ms = "ms",
     de = "de",
+    en = "en",
     la = "la",
-    br = "br",
     fr = "fr",
+    in = "in",
     it = "it",
     pl = "pl",
-    ru = "ru",
-    ua = "ua",
+    br = "br",
+    vn = "vn",
     tr = "tr",
+    kz = "kz",
+    ua = "ua",
+    ar = "ar",
+    th = "th",
     sc = "sc",
     tc = "tc",
-    ja = "ja",
-    vn = "vn",
-    id = "id",
-    ms = "ms",
-    th = "th",
-    ar = "ar"
+    ja = "ja"
 }
-/**
- * @todo add docs
- */
 declare const B24LocaleMap: Record<B24LangList, string>;
 
 /**
@@ -1626,7 +3324,7 @@ declare enum ConnectionType {
     LongPolling = "longPolling"
 }
 type TypeConnector = {
-    setLogger(logger: LoggerBrowser): void;
+    setLogger(logger: LoggerInterface): void;
     destroy(): void;
     connect(): void;
     disconnect(code: number, reason: string): void;
@@ -1666,8 +3364,8 @@ type StorageManagerParams = {
     siteId?: string;
 };
 type TypeStorageManager = {
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     set(name: string, value: any): void;
     get(name: string, defaultValue: any): any;
     remove(name: string): void;
@@ -1916,6 +3614,48 @@ type TypePullClientMessageBatch = {
     expiry?: number;
 };
 
+type SdkErrorDetails = {
+    code: string;
+    description?: string;
+    status: number;
+    originalError?: unknown;
+};
+/**
+ * Error in Sdk
+ */
+declare class SdkError extends Error {
+    readonly code: string;
+    protected _status: number;
+    readonly timestamp: Date;
+    readonly originalError?: unknown;
+    constructor(params: SdkErrorDetails);
+    get status(): number;
+    /**
+     * Creates SdkError from exception
+     */
+    static fromException(error: unknown, context?: {
+        code?: string;
+        status?: number;
+    }): SdkError;
+    /**
+     * Serializes error for logging and debugging
+     */
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+        status: number;
+        timestamp: string;
+        stack: string | undefined;
+    };
+    /**
+     * Formats error information for human-readable output
+     */
+    toString(): string;
+    protected static formatErrorMessage(params: SdkErrorDetails): string;
+    protected cleanErrorStack(): void;
+}
+
 type AnswerError = {
     error: string;
     errorDescription: string;
@@ -1925,88 +3665,320 @@ type AjaxErrorParams = {
     answerError: AnswerError;
     cause?: Error;
 };
-type ErrorDetails = {
-    code: string;
-    description?: string;
-    status: number;
-    requestInfo?: {
-        method?: string;
+type AjaxErrorDetails = SdkErrorDetails & {
+    requestInfo?: Partial<AjaxQuery> & {
         url?: string;
-        params?: Record<string, unknown> | unknown;
     };
-    originalError?: unknown;
-};
+};
+/**
+ * Error requesting RestApi
+ */
+declare class AjaxError extends SdkError {
+    readonly requestInfo?: AjaxErrorDetails['requestInfo'];
+    constructor(params: AjaxErrorDetails);
+    /**
+     * Creates AjaxError from HTTP response
+     * @todo add support v3
+     */
+    static fromResponse(response: {
+        status: number;
+        data?: {
+            error?: string;
+            error_description?: string;
+        };
+        config?: AjaxErrorDetails['requestInfo'];
+    }): AjaxError;
+    /**
+     * @inheritDoc
+     */
+    static fromException(error: unknown, context?: {
+        code?: string;
+        status?: number;
+        requestInfo?: AjaxErrorDetails['requestInfo'];
+    }): AjaxError;
+    /**
+     * @inheritDoc
+     */
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+        status: number;
+        timestamp: string;
+        requestInfo: (Partial<Readonly<{
+            method: string;
+            params: TypeCallParams;
+            requestId: string;
+        }>> & {
+            url?: string;
+        }) | undefined;
+        stack: string | undefined;
+    };
+    /**
+     * @inheritDoc
+     */
+    toString(): string;
+    /**
+     * @inheritDoc
+     */
+    protected static formatErrorMessage(params: AjaxErrorDetails): string;
+    /**
+     * @inheritDoc
+     */
+    protected cleanErrorStack(): void;
+}
+
+/**
+ * Factory for creating constraint parameters
+ */
+declare class ParamsFactory {
+    /**
+     * Default parameters for regular tariffs
+     *
+     * @see Http.#restrictionParams
+     */
+    static getDefault(): RestrictionParams;
+    /**
+     * Parameters for the Enterprise plan
+     */
+    static getEnterprise(): RestrictionParams;
+    /**
+     * Parameters for bulk data processing
+     */
+    static getBatchProcessing(): RestrictionParams;
+    /**
+     * Real-time parameters
+     */
+    static getRealtime(): RestrictionParams;
+    /**
+     * Tariff plan based parameters
+     */
+    static fromTariffPlan(plan: string): RestrictionParams;
+}
+
+/**
+ * Rate limiting (Leaky Bucket) with adaptive control
+ */
+declare class RateLimiter implements ILimiter {
+    #private;
+    private _logger;
+    constructor(config: RateLimitConfig);
+    getTitle(): string;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    /**
+     * @inheritDoc
+     */
+    canProceed(requestId: string, _method: string, _params?: any): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
+    waitIfNeeded(requestId: string, _method: string, _params?: any): Promise<number>;
+    /**
+     * Error handler.
+     * If there are a lot of errors, we'll lower the limits.
+     */
+    handleExceeded(requestId: string): Promise<number>;
+    /**
+     * Successful request handler.
+     * If everything is OK, we'll restore the limits.
+     */
+    updateStats(requestId: string, method: string, _data: any): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    reset(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    getStats(): {
+        tokens: number;
+        burstLimit: number;
+        originalBurstLimit: number;
+        drainRate: number;
+        originalDrainRate: number;
+        refillIntervalMs: number;
+        lastRefill: number;
+        pendingRequests: number;
+        recentErrors: number;
+        recentSuccesses: number;
+    };
+    /**
+     * @inheritDoc
+     */
+    setConfig(config: RateLimitConfig): Promise<void>;
+}
+
+interface OperatingStats {
+    operating: number;
+    /**
+     * reset time (timestamp in ms)
+     */
+    operating_reset_at: number;
+    lastUpdated: number;
+}
+/**
+ * Operating limiting
+ *
+ * @todo docs
+ */
+declare class OperatingLimiter implements ILimiter {
+    #private;
+    private _logger;
+    getTitle(): string;
+    constructor(config: OperatingLimitConfig);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    get limitMs(): number;
+    getMethodStat(method: string): undefined | OperatingStats;
+    canProceed(requestId: string, method: string, params?: any): Promise<boolean>;
+    waitIfNeeded(requestId: string, method: string, params?: any): Promise<number>;
+    /**
+     * Returns the time until the method's operating limit is released (in ms)
+     * The analysis is based on the previous function call.
+     * It's important to understand that we're talking about locks of up to 10 minutes.
+     * This is a fairly strict lock based on the limit:
+     *   - not reached - no lock
+     *   - reached - lock until the unlock time + 1 second
+     */
+    getTimeToFree(requestId: string, method: string, params?: any, _error?: any): Promise<number>;
+    /**
+     * Updates operating time statistics for the method
+     */
+    updateStats(requestId: string, method: string, data: PayloadTime): Promise<void>;
+    reset(): Promise<void>;
+    getStats(): {
+        heavyRequestCount: number;
+        operatingStats: {
+            [method: string]: number;
+        };
+    };
+    setConfig(config: OperatingLimitConfig): Promise<void>;
+}
+
 /**
- * Error requesting RestApi
+ * Adaptive delayer
+ *
+ * @todo docs
  */
-declare class AjaxError extends Error {
-    readonly code: string;
-    private _status;
-    readonly requestInfo?: ErrorDetails['requestInfo'];
-    readonly timestamp: Date;
-    readonly originalError?: unknown;
-    constructor(details: ErrorDetails);
+declare class AdaptiveDelayer implements ILimiter {
+    #private;
+    private _logger;
+    getTitle(): string;
+    constructor(config: AdaptiveConfig, operatingLimiter: OperatingLimiter);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    canProceed(_requestId: string, _method: string, _params?: any): Promise<boolean>;
+    /**
+     * Returns an adaptive delay based on previous experience
+     */
+    waitIfNeeded(requestId: string, method: string, params?: any): Promise<number>;
+    updateStats(_requestId: string, _method: string, _data: any): Promise<void>;
+    reset(): Promise<void>;
+    getStats(): {
+        adaptiveDelays: number;
+        totalAdaptiveDelay: number;
+        adaptiveDelayAvg: number;
+    };
+    setConfig(config: AdaptiveConfig): Promise<void>;
+    incrementAdaptiveDelays(): void;
+}
+
+/**
+ * Delay Management Manager
+ *
+ * @todo docs
+ */
+declare class RestrictionManager {
+    #private;
+    private _logger;
+    constructor(params: RestrictionParams);
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    applyOperatingLimits(requestId: string, method: string, params?: any): Promise<void>;
     /**
-     * @deprecated
+     * Checks and waits for the rate limit
+     * The loop is needed for parallel requests (Promise.all())
      */
-    get answerError(): AnswerError;
-    get status(): number;
+    checkRateLimit(requestId: string, method: string): Promise<void>;
+    updateStats(requestId: string, method: string, timeData: any): Promise<void>;
+    handleError(requestId: string, method: string, params: any, error: any, attempt: number): Promise<number>;
     /**
-     * @deprecated
+     * These exceptions will be thrown
      */
-    set status(status: number);
+    get exceptionCodeForHard(): string[];
     /**
-     * Creates AjaxError from HTTP response
+     * These exceptions will be thrown into `AjaxResult` as `AjaxError`
      */
-    static fromResponse(response: {
-        status: number;
-        data?: {
-            error?: string;
-            error_description?: string;
-        };
-        config?: {
-            method?: string;
-            url?: string;
-            params?: unknown;
-        };
-    }): AjaxError;
+    get exceptionCodeForSoft(): string[];
+    incrementError(method: string): void;
+    resetErrors(method: string): void;
+    incrementStats(stat: keyof Pick<RestrictionManagerStats, 'retries' | 'consecutiveErrors' | 'limitHits'>): void;
     /**
-     * Creates AjaxError from exception
+     * Returns job statistics
      */
-    static fromException(error: unknown, context?: {
-        code?: string;
-        status?: number;
-        requestInfo?: ErrorDetails['requestInfo'];
-    }): AjaxError;
+    getStats(): RestrictionManagerStats & {
+        adaptiveDelayAvg: number;
+        errorCounts: Record<string, number>;
+    };
     /**
-     * Serializes error for logging and debugging
+     * Resets limiters and statistics
      */
-    toJSON(): {
-        name: string;
-        code: string;
-        message: string;
-        status: number;
-        timestamp: string;
-        requestInfo: {
-            method?: string;
-            url?: string;
-            params?: Record<string, unknown> | unknown;
-        } | undefined;
-        stack: string | undefined;
-    };
+    reset(): Promise<void>;
+    setConfig(params: RestrictionParams): Promise<void>;
+    getParams(): RestrictionParams;
     /**
-     * Formats error information for human-readable output
+     * Public access to the delay function
      */
-    toString(): string;
-    private static formatErrorMessage;
-    private cleanErrorStack;
+    waiteDelay(ms: number): Promise<void>;
+}
+
+/**
+ * @todo add docs ??
+ */
+declare class VersionManager {
+    #private;
+    constructor();
+    static create(): VersionManager;
+    /**
+     * List of supported API versions
+     * The highest version must be first
+     */
+    getAllApiVersions(): ApiVersion[];
+    isSupport(version: ApiVersion, method: string): boolean;
+    /**
+     * Automatically obtain the API version
+     */
+    automaticallyObtainApiVersion(method: string): ApiVersion;
+    /**
+     * Automatically obtain the API version for Batch
+     *
+     * @todo test methods
+     *   `[['crm.item.get', { entityTypeId: 3, id: 1 }]]`
+     *   `[{ method: 'crm.item.get', params: { entityTypeId: 3, id: 1 } }]`
+     *   `{ cmd1: { method: 'crm.item.get', params: { entityTypeId: 3, id: 1 } }, cmd2: ['crm.item.get', { entityTypeId: 2, id: 2 }] }`
+     */
+    automaticallyObtainApiVersionForBatch(calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal): ApiVersion;
 }
+declare const versionManager: VersionManager;
 
+/**
+ * @todo docs
+ */
 declare abstract class AbstractB24 implements TypeB24 {
+    /**
+     * Maximum length for batch response.
+     *
+     * @deprecated This const is deprecated and will be removed in version `2.0.0`
+     * @removed 2.0.0
+     */
     static readonly batchSize = 50;
     protected _isInit: boolean;
-    protected _http: null | TypeHttp;
-    protected _logger: null | LoggerBrowser;
+    protected _httpV2: null | TypeHttp;
+    protected _httpV3: null | TypeHttp;
+    protected _logger: LoggerInterface;
+    protected _actionsManager: ActionsManager;
+    protected _toolsManager: ToolsManager;
     protected constructor();
     /**
      * @inheritDoc
@@ -2014,9 +3986,9 @@ declare abstract class AbstractB24 implements TypeB24 {
     get isInit(): boolean;
     init(): Promise<void>;
     destroy(): void;
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
     abstract get auth(): AuthActions;
+    get actions(): ActionsManager;
+    get tools(): ToolsManager;
     /**
      * @inheritDoc
      */
@@ -2024,32 +3996,76 @@ declare abstract class AbstractB24 implements TypeB24 {
     /**
      * @inheritDoc
      */
-    abstract getTargetOriginWithPath(): string;
+    abstract getTargetOriginWithPath(): Map<ApiVersion, string>;
     /**
-     * @inheritDoc
+     * Calls the Bitrix24 REST API method.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link CallV3.make `b24.actions.v3.call.make(options)`}
+     *   - for `restApi:v2` use {@link CallV2.make `b24.actions.v2.call.make(options)`}
+     *
+     * @removed 2.0.0
+     * @memo Only for `restApi:v2`
      */
     callMethod(method: string, params?: object, start?: number): Promise<AjaxResult>;
     /**
-     * @inheritDoc
+     * Calls a Bitrix24 REST API list method to retrieve all data.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link CallListV3.make `b24.actions.v3.callList.make(options)`}
+     *   - for `restApi:v2` use {@link CallListV2.make `b24.actions.v2.callList.make(options)`}
+     *
+     * @removed 2.0.0
+     * @memo Only for `restApi:v2`
      */
-    callListMethod(method: string, params?: object, progress?: null | ((progress: number) => void), customKeyForResult?: null | string): Promise<Result>;
+    callListMethod(method: string, params?: object, progress?: null | ((progress: number) => void), customKeyForResult?: string | null): Promise<Result>;
     /**
-     * @inheritDoc
+     * Calls a Bitrix24 REST API list method and returns an async generator.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link FetchListV3.make `b24.actions.v3.fetchList.make(options)`}
+     *   - for `restApi:v2` use {@link FetchListV2.make `b24.actions.v2.fetchList.make(options)`}
+     *
+     * @removed 2.0.0
+     * @memo Only for `restApi:v2`
      */
-    fetchListMethod(method: string, params?: any, idKey?: string, customKeyForResult?: null | string): AsyncGenerator<any[]>;
+    fetchListMethod(method: string, params?: any, idKey?: string, customKeyForResult?: string | null): AsyncGenerator<any[]>;
     /**
-     * @inheritDoc
+     * Executes a batch request to the Bitrix24 REST API.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link BatchV3.make `b24.actions.v3.batch.make(options)`}
+     *   - for `restApi:v2` use {@link BatchV2.make `b24.actions.v2.batch.make(options)`}
+     *
+     * @removed 2.0.0
+     * @memo Only for `restApi:v2`
      */
     callBatch(calls: Array<any> | object, isHaltOnError?: boolean, returnAjaxResult?: boolean): Promise<Result>;
-    chunkArray<T>(array: T[], chunkSize?: number): T[][];
+    /**
+     * Executes a batch request to the Bitrix24 REST API with automatic chunking for any number of commands.
+     *
+     * @deprecated This method is deprecated and will be removed in version `2.0.0`
+     *   - for `restApi:v3` use {@link BatchByChunkV3.make `b24.actions.v3.batchByChunk.make(options)`}
+     *   - for `restApi:v2` use {@link BatchByChunkV2.make `b24.actions.v2.batchByChunk.make(options)`}
+     *
+     * @removed 2.0.0
+     * @memo Only for `restApi:v2`
+     */
+    callBatchByChunk(calls: Array<any>, isHaltOnError: boolean): Promise<Result>;
+    /**
+     * @inheritDoc
+     */
+    getHttpClient(version: ApiVersion): TypeHttp;
     /**
      * @inheritDoc
      */
-    callBatchByChunk(calls: Array<any>, isHaltOnError?: boolean): Promise<Result>;
+    setHttpClient(version: ApiVersion, client: TypeHttp): void;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     /**
      * @inheritDoc
      */
-    getHttpClient(): TypeHttp;
+    setRestrictionManagerParams(params: RestrictionParams): Promise<void>;
     /**
      * Returns settings for http connection
      * @protected
@@ -2062,6 +4078,184 @@ declare abstract class AbstractB24 implements TypeB24 {
     protected _ensureInitialized(): void;
 }
 
+declare class RequestIdGenerator implements IRequestIdGenerator {
+    getQueryStringParameterName(): string;
+    getQueryStringSdkParameterName(): string;
+    getQueryStringSdkTypeParameterName(): string;
+    private generate;
+    getRequestId(): string;
+    getHeaderFieldName(): string;
+}
+
+type AjaxResponse<T = unknown> = {
+    status: number;
+    payload: SuccessPayload<T>;
+};
+type TypePrepareParams = TypeCallParams & {
+    data?: Record<string, any>;
+    auth?: string;
+};
+/**
+ * Abstract Class for working with RestApi requests via http
+ *
+ * @link https://bitrix24.github.io/b24jssdk/
+ *
+ * @todo docs
+ */
+declare abstract class AbstractHttp implements TypeHttp {
+    protected _clientAxios: AxiosInstance;
+    protected _authActions: AuthActions;
+    protected _requestIdGenerator: RequestIdGenerator;
+    protected _restrictionManager: RestrictionManager;
+    protected _logger: LoggerInterface;
+    protected _isClientSideWarning: boolean;
+    protected _clientSideWarningMessage: string;
+    protected _version: ApiVersion;
+    protected _metrics: {
+        totalRequests: number;
+        successfulRequests: number;
+        failedRequests: number;
+        totalDuration: number;
+        byMethod: Map<string, {
+            count: number;
+            totalDuration: number;
+        }>;
+        lastErrors: Array<{
+            method: string;
+            error: string;
+            timestamp: number;
+        }>;
+    };
+    constructor(authActions: AuthActions, options?: null | object, restrictionParams?: Partial<RestrictionParams>);
+    get apiVersion(): ApiVersion;
+    get ajaxClient(): AxiosInstance;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    setRestrictionManagerParams(params: RestrictionParams): Promise<void>;
+    getRestrictionManagerParams(): RestrictionParams;
+    /**
+     * @inheritDoc
+     */
+    getStats(): RestrictionManagerStats & {
+        adaptiveDelayAvg: number;
+        errorCounts: Record<string, number>;
+        totalRequests: number;
+        successfulRequests: number;
+        failedRequests: number;
+        totalDuration: number;
+        byMethod: Map<string, {
+            count: number;
+            totalDuration: number;
+        }>;
+        lastErrors: {
+            method: string;
+            error: string;
+            timestamp: number;
+        }[];
+    };
+    /**
+     * @inheritDoc
+     */
+    reset(): Promise<void>;
+    protected _updateMetrics(method: string, isSuccess: boolean, duration: number, error?: unknown): void;
+    abstract batch<T = unknown>(calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal, options?: ICallBatchOptions): Promise<Result<ICallBatchResult<T>>>;
+    protected _validateParams(requestId: string, method: string, params: TypeCallParams): void;
+    /**
+     * Calling the RestApi function
+     * @param method - REST API method name
+     * @param params - Parameters for the method.
+     * @param requestId - Request id
+     * @returns Promise with AjaxResult
+     */
+    call<T = unknown>(method: string, params: TypeCallParams, requestId?: string): Promise<AjaxResult<T>>;
+    protected _convertToAjaxError(requestId: string, error: unknown, method: string, params: TypeCallParams): AjaxError;
+    protected _convertAxiosErrorToAjaxError(requestId: string, axiosError: AxiosError, method: string, params: TypeCallParams): AjaxError;
+    protected _convertUnknownErrorToAjaxError(requestId: string, error: unknown, method: string, params: TypeCallParams): AjaxError;
+    /**
+     * Performs a single call with
+     * - 401 error handling
+     * - rate limit check
+     * - updating operating statistics
+     */
+    protected _executeSingleCall<T = unknown>(requestId: string, method: string, params: TypeCallParams): Promise<AjaxResult<T>>;
+    protected _ensureAuth(requestId: string): Promise<AuthData>;
+    protected _makeRequestWithAuthRetry<T>(requestId: string, method: string, params: TypeCallParams, authData: AuthData): Promise<AjaxResponse<T>>;
+    protected _makeAxiosRequest<T>(requestId: string, method: string, params: TypeCallParams, authData: AuthData): Promise<AjaxResponse<T>>;
+    protected _isAuthError(error: unknown): boolean;
+    protected _createAjaxResultFromResponse<T>(response: AjaxResponse<T>, requestId: string, method: string, params: TypeCallParams): Promise<AjaxResult<T>>;
+    /**
+     * This works in conjunction with the AbstractHttp._convertAxiosErrorToAjaxError function
+     */
+    protected _createAjaxResultWithErrorFromResponse<T>(ajaxError: AjaxError, requestId: string, method: string, params: TypeCallParams): AjaxResult<T>;
+    /**
+     * Makes the function name safe and adds JSON format
+     */
+    protected abstract _prepareMethod(requestId: string, method: string, baseUrl: string): string;
+    /**
+     * Processes function parameters and adds authorization
+     */
+    protected _prepareParams(authData: AuthData, params: TypeCallParams): TypePrepareParams;
+    /**
+     * @inheritDoc
+     */
+    setClientSideWarning(value: boolean, message: string): void;
+    /**
+     * Tests whether the code is executed on the client side
+     * @return {boolean}
+     * @protected
+     */
+    protected isServerSide(): boolean;
+    /**
+     * Get the BX24 account address with the path based on the API version
+     */
+    getBaseUrl(): string;
+    protected _sanitizeParams(params: TypeCallParams): Record<string, unknown>;
+    protected _logRequest(requestId: string, method: string, params: TypeCallParams): void;
+    protected _logAttempt(requestId: string, method: string, attempt: number, maxRetries: number): void;
+    protected _logRefreshingAuthToken(requestId: string): void;
+    protected _logAuthErrorDetected(requestId: string): void;
+    protected _logSuccessfulRequest(requestId: string, method: string, duration: number): void;
+    protected _logFailedRequest(requestId: string, method: string, attempt: number, maxRetries: number, error: AjaxError): void;
+    protected _logAttemptRetryWaiteDelay(requestId: string, method: string, wait: number, attempt: number, maxRetries: number): void;
+    protected _logAllAttemptsExhausted(requestId: string, method: string, attempt: number, maxRetries: number): void;
+    protected _logBatchStart(requestId: string, calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal, options: ICallBatchOptions): void;
+    protected _logBatchCompletion(requestId: string, total: number, errors: number): void;
+    protected _checkClientSideWarning(requestId: string): void;
+}
+
+/**
+ * Class for working with RestApi v2 requests via http
+ *
+ * @link https://bitrix24.github.io/b24jssdk/
+ *
+ * @todo docs
+ */
+declare class HttpV2 extends AbstractHttp implements TypeHttp {
+    constructor(authActions: AuthActions, options?: null | object, restrictionParams?: Partial<RestrictionParams>);
+    batch<T = unknown>(calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal, options?: ICallBatchOptions): Promise<Result<ICallBatchResult<T>>>;
+    /**
+     * @inheritDoc
+     */
+    protected _prepareMethod(requestId: string, method: string, baseUrl: string): string;
+}
+
+/**
+ * Class for working with RestApi v3 requests via http
+ *
+ * @link https://bitrix24.github.io/b24jssdk/
+ * @link https://apidocs.bitrix24.com/api-reference/rest-v3/index.html
+ *
+ * @todo docs
+ */
+declare class HttpV3 extends AbstractHttp implements TypeHttp {
+    constructor(authActions: AuthActions, options?: null | object, restrictionParams?: Partial<RestrictionParams>);
+    batch<T = unknown>(calls: BatchCommandsArrayUniversal | BatchCommandsObjectUniversal | BatchNamedCommandsUniversal, options?: ICallBatchOptions): Promise<Result<ICallBatchResult<T>>>;
+    /**
+     * @inheritDoc
+     */
+    protected _prepareMethod(requestId: string, method: string, baseUrl: string): string;
+}
+
 declare class FormatterNumbers {
     private static isInternalConstructing;
     private static instance;
@@ -2097,7 +4291,7 @@ declare class IbanSpecification {
     /**
      * Check if the passed iban is valid, according to this specification.
      *
-     * @param {String} iban the iban to validate
+     * @param {string} iban the iban to validate
      * @returns {boolean} true if valid, false otherwise
      */
     isValid(iban: string): boolean;
@@ -2155,7 +4349,7 @@ declare class IbanSpecification {
      * Calculates MOD 97 10 of the passed IBAN as specified in ISO7064.
      *
      * @param iban
-     * @returns {number}
+     * @returns {number} MOD
      */
     private _iso7064Mod9710;
 }
@@ -2172,7 +4366,7 @@ declare class FormatterIban {
     /**
      * Check if an IBAN is valid.
      *
-     * @param {String} iban the IBAN to validate.
+     * @param {string} iban the IBAN to validate.
      * @returns {boolean} true if the passed IBAN is valid, false otherwise
      */
     isValid(iban: string): boolean;
@@ -2182,8 +4376,8 @@ declare class FormatterIban {
      * Convert an IBAN to a BBAN.
      *
      * @param iban
-     * @param {String} [separator] the separator to use between the blocks of the BBAN, defaults to ' '
-     * @returns {string|*}
+     * @param {string} [separator] the separator to use between the blocks of the BBAN, defaults to ' '
+     * @returns {string|*} Convert an IBAN to a BBAN.
      */
     toBBAN(iban: string, separator?: string): string;
     /**
@@ -2213,26 +4407,38 @@ declare const useFormatter: () => {
 /**
  * B24.Hook Manager.
  *
- * @link https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=99&LESSON_ID=8581&LESSON_PATH=8771.8583.8581
+ * @link https://bitrix24.github.io/b24jssdk/docs/hook/
+ *
+ * @todo docs
  */
 declare class B24Hook extends AbstractB24 implements TypeB24 {
     #private;
-    constructor(b24HookParams: B24HookParams);
-    setLogger(logger: LoggerBrowser): void;
+    constructor(b24HookParams: B24HookParams, options?: {
+        restrictionParams?: Partial<RestrictionParams>;
+    });
     get auth(): AuthActions;
     /**
      * Disables warning about client-side query execution
      */
     offClientSideWarning(): void;
     /**
-     * Get the account address BX24 ( https://name.bitrix24.com )
+     * @inheritDoc
      */
     getTargetOrigin(): string;
     /**
-     * Get the account address BX24 with Path ( https://name.bitrix24.com/rest/1/xxxxx )
+     * @inheritDoc
+     */
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
+    /**
+     * Init Webhook from url
+     *   - ver2 `https://your_domain.bitrix24.com/rest/{id}/{webhook}`
+     *   - ver3 `https://your_domain.bitrix24.com/rest/api/{id}/{webhook}`
+     *
+     * @todo docs
      */
-    getTargetOriginWithPath(): string;
-    static fromWebhookUrl(url: string): B24Hook;
+    static fromWebhookUrl(url: string, options?: {
+        restrictionParams?: Partial<RestrictionParams>;
+    }): B24Hook;
 }
 
 /**
@@ -2248,13 +4454,15 @@ declare class AuthHookManager implements AuthActions {
     refreshAuth(): Promise<AuthData>;
     getUniq(prefix: string): string;
     /**
-     * Get the account address BX24 ( https://name.bitrix24.com )
+     * @inheritDoc
      */
     getTargetOrigin(): string;
     /**
-     * Get the account address BX24 with Path ( https://name.bitrix24.com/rest/1/xxxxx )
+     * Get the account address BX24 with path
+     *   - ver2 `https://your_domain.bitrix24.com/rest/{id}/{webhook}`
+     *   - ver3` https://your_domain.bitrix24.com/rest/api/{id}/{webhook}`
      */
-    getTargetOriginWithPath(): string;
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
     /**
      * We believe that hooks are created only by the admin
      */
@@ -2285,6 +4493,9 @@ declare enum MessageCommands {
     selectUser = "selectUser",
     selectAccess = "selectAccess",
     selectCRM = "selectCRM",
+    /**
+     * @memo this not work. Need test
+     */
     showAppForm = "showAppForm",
     getInterface = "getInterface",
     placementBindEvent = "placementBindEvent"
@@ -2306,18 +4517,20 @@ declare class AppFrame {
      */
     getAppSid(): string;
     /**
-     * Get the account address BX24 (https://name.bitrix24.com)
+     * Get the account address BX24 (https://your_domain.bitrix24.com)
      */
     getTargetOrigin(): string;
     /**
-     * Get the account address BX24 with Path (https://name.bitrix24.com/rest)
+     * Get the account address BX24 with path
+     *   - ver2 `https://your_domain.bitrix24.com/rest/`
+     *   - ver3` https://your_domain.bitrix24.com/rest/api/`
      */
-    getTargetOriginWithPath(): string;
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
     /**
      * Returns the localization of the B24 interface
-     * @return {B24LangList} - default B24LangList.en
+     * @return {B24LangList} - default `B24LangList.en`
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-get-lang.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-get-lang.html
      */
     getLang(): B24LangList;
 }
@@ -2341,11 +4554,11 @@ interface SendParams {
  */
 declare class MessageManager {
     #private;
-    protected _logger: null | LoggerBrowser;
+    protected _logger: LoggerInterface;
     private readonly runCallbackHandler;
     constructor(appFrame: AppFrame);
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     /**
      * Subscribe to the onMessage event of the parent window
      */
@@ -2374,7 +4587,7 @@ declare class MessageManager {
 /**
  * Parent window manager
  *
- * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/
+ * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/
  */
 declare class ParentManager {
     #private;
@@ -2384,7 +4597,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-close-application.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-close-application.html
      */
     closeApplication(): Promise<void>;
     /**
@@ -2392,7 +4605,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-fit-window.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-fit-window.html
      *
      * @memo in certain situations it may not be executed (placement of the main window after installing the application), in this case isSafely mode will work
      */
@@ -2405,7 +4618,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-resize-window.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-resize-window.html
      *
      * @memo in certain situations it may not be executed, in this case isSafely mode will be triggered
      */
@@ -2426,7 +4639,7 @@ declare class ParentManager {
      *
      * @return {Promise<{scrollWidth: number; scrollHeight: number}>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-get-scroll-size.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-get-scroll-size.html
      */
     getScrollSize(): {
         scrollWidth: number;
@@ -2438,7 +4651,7 @@ declare class ParentManager {
      * @param {number} scroll should specify the vertical scrollbar position (0 - scroll to the very top)
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-scroll-parent-window.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-scroll-parent-window.html
      */
     scrollParentWindow(scroll: number): Promise<void>;
     /**
@@ -2446,7 +4659,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-reload-window.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-reload-window.html
      */
     reloadWindow(): Promise<void>;
     /**
@@ -2456,7 +4669,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-set-title.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-set-title.html
      */
     setTitle(title: string): Promise<void>;
     /**
@@ -2467,7 +4680,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-im-call-to.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-im-call-to.html
      */
     imCallTo(userId: number, isVideo?: boolean): Promise<void>;
     /**
@@ -2477,7 +4690,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-im-phone-to.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-im-phone-to.html
      */
     imPhoneTo(phone: string): Promise<void>;
     /**
@@ -2493,7 +4706,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-im-open-messenger.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-im-open-messenger.html
      * @link https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=93&LESSON_ID=20152&LESSON_PATH=7657.7883.8025.20150.20152
      *
      */
@@ -2509,7 +4722,7 @@ declare class ParentManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-im-open-history.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-im-open-history.html
      */
     imOpenHistory(dialogId: number | `chat${number}` | `imol|${number}`): Promise<void>;
 }
@@ -2517,7 +4730,7 @@ declare class ParentManager {
 /**
  * Manager for working with application settings via communication with the parent window
  *
- * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/options/index.html
+ * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/options/index.html
  */
 declare class OptionsManager$1 {
     #private;
@@ -2530,25 +4743,25 @@ declare class OptionsManager$1 {
     /**
      * Getting application option
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/options/bx24-app-option-get.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/options/bx24-app-option-get.html
      */
     appGet(option: string): any;
     /**
      * Updates application data through the parent window
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/options/bx24-app-option-set.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/options/bx24-app-option-set.html
      */
     appSet(option: string, value: any): Promise<void>;
     /**
      * Getting user option
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/options/bx24-user-option-get.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/options/bx24-user-option-get.html
      */
     userGet(option: string): any;
     /**
      * Updates user data through the parent window
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/options/bx24-user-option-set.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/options/bx24-user-option-set.html
      */
     userSet(option: string, value: any): Promise<void>;
 }
@@ -2649,7 +4862,7 @@ type SelectedCRM = {
 /**
  * Select dialog manager
  *
- * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-dialogues/index.html
+ * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-dialogues/index.html
  */
 declare class DialogManager {
     #private;
@@ -2660,7 +4873,7 @@ declare class DialogManager {
      *
      * @return {Promise<null|SelectedUser>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-dialogues/bx24-select-user.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-dialogues/bx24-select-user.html
      */
     selectUser(): Promise<null | SelectedUser>;
     /**
@@ -2669,27 +4882,25 @@ declare class DialogManager {
      *
      * @return {Promise<SelectedUser[]>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-dialogues/bx24-select-users.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-dialogues/bx24-select-users.html
      */
     selectUsers(): Promise<SelectedUser[]>;
     /**
-     * @deprecated
      * Method displays a standard access permission selection dialog
      *
      * @param {string[]} blockedAccessPermissions
      * @return {Promise<SelectedAccess[]>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-dialogues/bx24-select-access.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-dialogues/bx24-select-access.html
      */
     selectAccess(blockedAccessPermissions?: string[]): Promise<SelectedAccess[]>;
     /**
-     * @deprecated
      * Method invokes the system dialog for selecting a CRM entity
      *
      * @param {SelectCRMParams} params
      * @return {Promise<SelectedCRM>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-dialogues/bx24-select-crm.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-dialogues/bx24-select-crm.html
      */
     selectCRM(params?: SelectCRMParams): Promise<SelectedCRM>;
 }
@@ -2711,7 +4922,7 @@ declare class SliderManager {
     /**
      * When the method is called, a pop-up window with the application frame will be opened.
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-open-application.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-open-application.html
      */
     openSliderAppPage(params?: any): Promise<any>;
     /**
@@ -2719,7 +4930,7 @@ declare class SliderManager {
      *
      * @return {Promise<void>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-close-application.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-close-application.html
      */
     closeSliderAppPage(): Promise<void>;
     /**
@@ -2728,22 +4939,16 @@ declare class SliderManager {
      * @param {number} width - Number in the range from 1640 to 1200, from 1200 to 950, from 950 to 900, from 900 ...
      * @return {Promise<StatusClose>}
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-open-path.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-open-path.html
      * @memo /^\/(crm\/(deal|lead|contact|company|type)|marketplace|company\/personal\/user\/[0-9]+|workgroups\/group\/[0-9]+)\//
      */
     openPath(url: URL, width?: number): Promise<StatusClose>;
-    /**
-     * @deprecated
-     * @param params
-     */
-    showAppForm(params: any): Promise<void>;
 }
 
 /**
  * Placement Manager
  *
  * @see https://apidocs.bitrix24.com/api-reference/widgets/ui-interaction/index.html
- * @see https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=99&CHAPTER_ID=02535&LESSON_PATH=8771.5380.2535
  */
 declare class PlacementManager {
     #private;
@@ -2753,7 +4958,12 @@ declare class PlacementManager {
      * @param data
      */
     initData(data: MessageInitData): PlacementManager;
+    /**
+     * Symlink on `placement`
+     * For backward compatibility
+     */
     get title(): string;
+    get placement(): string;
     get isDefault(): boolean;
     get options(): any;
     get isSliderMode(): boolean;
@@ -2799,12 +5009,17 @@ declare class PlacementManager {
  * B24 Manager. Replacement api.bitrix24.com
  *
  * @link https://api.bitrix24.com/api/v1/
+ * @link https://bitrix24.github.io/b24jssdk/docs/frame/
  * @see /bitrix/js/rest/applayout.js
+ *
+ * @todo add docs
  */
 declare class B24Frame extends AbstractB24 implements TypeB24 {
     #private;
-    constructor(queryParams: B24FrameQueryParams);
-    setLogger(logger: LoggerBrowser): void;
+    constructor(queryParams: B24FrameQueryParams, options?: {
+        restrictionParams?: Partial<RestrictionParams>;
+    });
+    setLogger(logger: LoggerInterface): void;
     get isFirstRun(): boolean;
     get isInstallMode(): boolean;
     get parent(): ParentManager;
@@ -2822,17 +5037,17 @@ declare class B24Frame extends AbstractB24 implements TypeB24 {
     /**
      * Signals that the installer or application setup has finished running.
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-functions/bx24-install-finish.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-functions/bx24-install-finish.html
      */
     installFinish(): Promise<any>;
     /**
-     * Get the account address BX24 ( https://name.bitrix24.com )
+     * @inheritDoc
      */
     getTargetOrigin(): string;
     /**
-     * Get the account address BX24 with Path ( https://name.bitrix24.com/rest )
+     * @inheritDoc
      */
-    getTargetOriginWithPath(): string;
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
     /**
      * Returns the sid of the application relative to the parent window like this `9c33468728e1d2c8c97562475edfd96`
      */
@@ -2840,7 +5055,7 @@ declare class B24Frame extends AbstractB24 implements TypeB24 {
     /**
      * Returns the localization of the B24 interface
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-get-lang.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-get-lang.html
      */
     getLang(): B24LangList;
 }
@@ -2859,39 +5074,92 @@ declare class AuthManager implements AuthActions {
     /**
      * Returns authorization data
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-functions/bx24-get-auth.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-functions/bx24-get-auth.html
      */
     getAuthData(): false | AuthData;
     /**
      * Updates authorization data through the parent window
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/system-functions/bx24-refresh-auth.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/system-functions/bx24-refresh-auth.html
      */
     refreshAuth(): Promise<AuthData>;
     getUniq(prefix: string): string;
     /**
      * Determines whether the current user has administrator rights
      *
-     * @link https://apidocs.bitrix24.com/api-reference/bx24-js-sdk/additional-functions/bx24-is-admin.html
+     * @link https://apidocs.bitrix24.com/sdk/bx24-js-sdk/additional-functions/bx24-is-admin.html
      */
     get isAdmin(): boolean;
+    /**
+     * @inheritDoc
+     */
+    getTargetOrigin(): string;
+    /**
+     * @inheritDoc
+     */
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
+}
+
+declare class RefreshTokenError extends SdkError {
 }
 
 /**
- * B24.OAuth Manager
- * @todo add docs
+ * OAuth Authorization Manager
  *
- * @link https://apidocs.bitrix24.com/api-reference/oauth/index.html
+ * @link https://apidocs.bitrix24.com/settings/oauth/index.html
+ * @link https://bitrix24.github.io/b24jssdk/docs/oauth/
  */
+declare class AuthOAuthManager implements AuthActions {
+    #private;
+    constructor(b24OAuthParams: B24OAuthParams, oAuthSecret: B24OAuthSecret);
+    /**
+     * Returns authorization data
+     * @see Http.#prepareParams
+     */
+    getAuthData(): false | AuthData;
+    /**
+     * Updates authorization data
+     */
+    refreshAuth(): Promise<AuthData>;
+    setCallbackRefreshAuth(cb: CallbackRefreshAuth): void;
+    removeCallbackRefreshAuth(): void;
+    setCustomRefreshAuth(cb: CustomRefreshAuth): void;
+    removeCustomRefreshAuth(): void;
+    getUniq(prefix: string): string;
+    /**
+     * @inheritDoc
+     */
+    getTargetOrigin(): string;
+    /**
+     * @inheritDoc
+     */
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
+    /**
+     * Determines whether the current user has administrator rights
+     */
+    get isAdmin(): boolean;
+    initIsAdmin(http: TypeHttp, requestId?: string): Promise<void>;
+}
 
+/**
+ * B24.OAuth Manager
+ *
+ * @link https://apidocs.bitrix24.com/settings/oauth/index.html
+ * @link https://bitrix24.github.io/b24jssdk/docs/oauth/
+ *
+ * @todo add docs
+ */
 declare class B24OAuth extends AbstractB24 implements TypeB24 {
     #private;
-    constructor(authOptions: B24OAuthParams, oAuthSecret: B24OAuthSecret);
-    setLogger(logger: LoggerBrowser): void;
+    constructor(authOptions: B24OAuthParams, oAuthSecret: B24OAuthSecret, options?: {
+        restrictionParams?: Partial<RestrictionParams>;
+    });
     /**
      * Used to initialize information about the current user.
+     *
+     * @todo test this
      */
-    initIsAdmin(): Promise<void>;
+    initIsAdmin(requestId?: string): Promise<void>;
     /**
      * Sets an asynchronous Callback to receive updated authorization data
      * @param cb
@@ -2916,59 +5184,26 @@ declare class B24OAuth extends AbstractB24 implements TypeB24 {
     offClientSideWarning(): void;
     get auth(): AuthActions;
     /**
-     * Get the account address BX24 ( https://name.bitrix24.com )
-     */
-    getTargetOrigin(): string;
-    /**
-     * Get the account address BX24 with Path ( https://name.bitrix24.com/rest/1/xxxxx )
-     */
-    getTargetOriginWithPath(): string;
-}
-
-declare class AuthOAuthManager implements AuthActions {
-    #private;
-    constructor(b24OAuthParams: B24OAuthParams, oAuthSecret: B24OAuthSecret);
-    /**
-     * Returns authorization data
-     * @see Http.#prepareParams
-     */
-    getAuthData(): false | AuthData;
-    /**
-     * Updates authorization data
-     */
-    refreshAuth(): Promise<AuthData>;
-    setCallbackRefreshAuth(cb: CallbackRefreshAuth): void;
-    removeCallbackRefreshAuth(): void;
-    setCustomRefreshAuth(cb: CustomRefreshAuth): void;
-    removeCustomRefreshAuth(): void;
-    getUniq(prefix: string): string;
-    /**
-     * Get the account address BX24 ( https://name.bitrix24.com )
+     * @inheritDoc
      */
     getTargetOrigin(): string;
     /**
-     * Get the account address BX24 with Path ( https://name.bitrix24.com/rest )
-     */
-    getTargetOriginWithPath(): string;
-    /**
-     * Determines whether the current user has administrator rights
+     * @inheritDoc
      */
-    get isAdmin(): boolean;
-    initIsAdmin(http: TypeHttp): Promise<void>;
+    getTargetOriginWithPath(): Map<ApiVersion, string>;
 }
 
 declare abstract class AbstractHelper {
     protected _b24: TypeB24;
-    protected _logger: null | LoggerBrowser;
     protected _data: any;
+    protected _logger: LoggerInterface;
     constructor(b24: TypeB24);
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     /**
      * Initializes the data received
-     * @param data
      */
-    initData(data: any): Promise<void>;
+    initData(_data: any): Promise<void>;
     abstract get data(): any;
 }
 
@@ -3011,7 +5246,7 @@ declare class LicenseManager extends AbstractHelper {
      * Set RestrictionManager params by license
      * @link https://apidocs.bitrix24.com/api-reference/common/system/app-info.html
      */
-    makeRestrictionManagerParams(): void;
+    makeRestrictionManagerParams(): Promise<void>;
 }
 
 type CurrencyFormatInit = {
@@ -3097,7 +5332,6 @@ declare class OptionsManager extends AbstractHelper {
  */
 declare class B24HelperManager {
     private readonly _b24;
-    protected _logger: null | LoggerBrowser;
     private _isInit;
     private _profile;
     private _app;
@@ -3109,9 +5343,10 @@ declare class B24HelperManager {
     private _b24PullClient;
     private _pullClientUnSubscribe;
     private _pullClientModuleId;
+    protected _logger: LoggerInterface;
     constructor(b24: TypeB24);
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     destroy(): void;
     loadData(dataTypes?: LoadDataType[]): Promise<void>;
     private parseUserData;
@@ -3123,7 +5358,7 @@ declare class B24HelperManager {
     get isInit(): boolean;
     get forB24Form(): TypeB24Form;
     /**
-     * Get the account address BX24 (https://name.bitrix24.com)
+     * Get the account address BX24 (https://your_domain.bitrix24.com)
      */
     get hostName(): string;
     get profileInfo(): ProfileManager;
@@ -3164,9 +5399,6 @@ declare const useB24Helper: () => {
     startPullClient: () => void;
 };
 
-/**
- * @todo fix logic for _loggingEnabled
- */
 declare class PullClient implements ConnectorParent {
     private _logger;
     private _restClient;
@@ -3219,8 +5451,8 @@ declare class PullClient implements ConnectorParent {
      * @param params
      */
     constructor(params: TypePullClientParams);
-    setLogger(logger: LoggerBrowser): void;
-    getLogger(): LoggerBrowser;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
     destroy(): void;
     private init;
     get connector(): null | TypeConnector;
@@ -3390,9 +5622,6 @@ declare class PullClient implements ConnectorParent {
      */
     private emitUserStatusChange;
     private restoreUserStatusSubscription;
-    /**
-     * @param logTag
-     */
     private loadConfig;
     /**
      * @param config
@@ -3563,7 +5792,10 @@ declare class PullClient implements ConnectorParent {
     private onCustomEvent;
 }
 
-declare function initializeB24Frame(): Promise<B24Frame>;
+declare function initializeB24Frame(options?: {
+    version?: ApiVersion;
+    restrictionParams?: Partial<RestrictionParams>;
+}): Promise<B24Frame>;
 
-export { AbstractB24, AjaxError, AjaxResult, AppFrame, AuthHookManager, AuthManager, AuthOAuthManager, B24Frame, B24Hook, B24LangList, B24LocaleMap, B24OAuth, PullClient as B24PullClientManager, Browser, CatalogProductImageType, CatalogProductType, CatalogRoundingRuleType, CloseReasons, ConnectionType, DataType, DialogManager, EnumAppStatus, EnumBitrix24Edition, EnumBizprocBaseType, EnumBizprocDocumentType, EnumCrmEntityType, EnumCrmEntityTypeId, EnumCrmEntityTypeShort, ListRpcError, LoadDataType, LoggerBrowser, LoggerType, LsKeys, MessageCommands, MessageManager, OptionsManager$1 as OptionsManager, ParentManager, PlacementManager, ProductRowDiscountTypeId, PullStatus, RestrictionManagerParamsBase, RestrictionManagerParamsForEnterprise, Result, RpcMethod, SenderType, ServerMode, SliderManager, StatusDescriptions, SubscriptionType, SystemCommands, Text$1 as Text, Type, TypeOption, TypeSpecificUrl, convertBizprocDocumentTypeToCrmEntityTypeId, getDocumentId, getDocumentType, getDocumentTypeForFilter, getEnumCrmEntityTypeShort, getEnumValue, initializeB24Frame, isArrayOfArray, omit, pick, useB24Helper, useFormatter };
-export type { ActivityConfig, ActivityHandlerParams, ActivityOrRobotConfig, ActivityProperty, ActivityPropertyType, AjaxErrorParams, AjaxQuery, AjaxResultParams, AnswerError, AuthActions, AuthData, B24FrameQueryParams, B24HookParams, B24OAuthParams, B24OAuthSecret, BatchPayload, BoolString, CallbackRefreshAuth, CatalogCatalog, CatalogExtra, CatalogLanguage, CatalogMeasure, CatalogPriceType, CatalogPriceTypeLang, CatalogProduct, CatalogProductImage, CatalogProductOffer, CatalogProductService, CatalogProductSku, CatalogRatio, CatalogRoundingRule, CatalogSection, CatalogStore, CatalogVat, CommandHandlerFunctionV1, CommandHandlerFunctionV2, ConnectorCallbacks, ConnectorConfig, ConnectorParent, CrmItemDelivery, CrmItemPayment, CrmItemProductRow, Currency, CurrencyFormat, CustomRefreshAuth, EventHandlerParams, EventOnAppInstallHandlerParams, EventOnAppUnInstallHandlerParams, Fields, GenderString, GetPayload, HandlerAuthParams, HandlerRefreshAuth, IPlacementUF, IRequestIdGenerator, IResult, ISODate, JsonRpcRequest, ListPayload, MessageInitData, MultiField, MultiFieldArray, NumberString, Payload, PayloadOAuthToken, PayloadTime, PlacementViewMode, RefreshAuthData, RpcCommand, RpcCommandResult, RpcError, RpcRequest, SelectCRMParams, SelectCRMParamsEntityType, SelectCRMParamsValue, SelectedAccess, SelectedCRM, SelectedCRMEntity, SelectedUser, SendParams, SharedConfigCallbacks, SharedConfigParams, StatusClose, StorageManagerParams, TextType, TypeApp, TypeB24, TypeB24Form, TypeChanel, TypeChannelManagerParams, TypeConnector, TypeDescriptionError, TypeEnumAppStatus, TypeHttp, TypeJsonRpcConfig, TypeLicense, TypePayment, TypePublicIdDescriptor, TypePullClientConfig, TypePullClientEmitConfig, TypePullClientMessageBatch, TypePullClientMessageBody, TypePullClientParams, TypePullClientSession, TypePullMessage, TypeRestrictionManagerParams, TypeRpcResponseAwaiters, TypeSessionEvent, TypeStorageManager, TypeSubscriptionCommandHandler, TypeSubscriptionOptions, TypeUser, UserBasic, UserBrief, UserFieldType, UserStatusCallback };
+export { AbstractB24, AbstractLogger, AdaptiveDelayer, AjaxError, AjaxResult, ApiVersion, AppFrame, AuthHookManager, AuthManager, AuthOAuthManager, B24Frame, B24Hook, B24LangList, B24LocaleMap, B24OAuth, PullClient as B24PullClientManager, Browser, CatalogProductImageType, CatalogProductType, CatalogRoundingRuleType, CloseReasons, ConnectionType, ConsolaAdapter, ConsoleHandler, ConsoleV2Handler, DataType, DialogManager, EnumAppStatus, EnumBitrix24Edition, EnumBizprocBaseType, EnumBizprocDocumentType, EnumCrmEntityType, EnumCrmEntityTypeId, EnumCrmEntityTypeShort, Environment, HttpV2, HttpV3, JsonFormatter, LineFormatter, ListRpcError, LoadDataType, LogLevel, Logger, LoggerBrowser, LoggerFactory, LoggerType, LsKeys, MemoryHandler, MessageCommands, MessageManager, NullLogger, OperatingLimiter, OptionsManager$1 as OptionsManager, ParamsFactory, ParentManager, PlacementManager, ProductRowDiscountTypeId, PullStatus, RateLimiter, RefreshTokenError, RestrictionManager, Result, RpcMethod, SdkError, SenderType, ServerMode, SliderManager, StatusDescriptions, StreamHandler, SubscriptionType, SystemCommands, TelegramFormatter, TelegramHandler, Text$1 as Text, Type, TypeOption, TypeSpecificUrl, WinstonAdapter, convertBizprocDocumentTypeToCrmEntityTypeId, getDocumentId, getDocumentType, getDocumentTypeForFilter, getEnumCrmEntityTypeShort, getEnumValue, getEnvironment, initializeB24Frame, isArrayOfArray, memoryUsageProcessor, omit, pick, pidProcessor, useB24Helper, useFormatter, versionManager };
+export type { ActivityConfig, ActivityHandlerParams, ActivityOrRobotConfig, ActivityProperty, ActivityPropertyType, AdaptiveConfig, AjaxErrorParams, AjaxQuery, AnswerError, AuthActions, AuthData, B24FrameQueryParams, B24HookParams, B24OAuthParams, B24OAuthSecret, BatchCommandV3, BatchCommandsArrayUniversal, BatchCommandsObjectUniversal, BatchCommandsUniversal, BatchNamedCommandsUniversal, BatchPayload, BatchPayloadResult, BoolString, CallBatchResult, CallbackRefreshAuth, CatalogCatalog, CatalogExtra, CatalogLanguage, CatalogMeasure, CatalogPriceType, CatalogPriceTypeLang, CatalogProduct, CatalogProductImage, CatalogProductOffer, CatalogProductService, CatalogProductSku, CatalogRatio, CatalogRoundingRule, CatalogSection, CatalogStore, CatalogVat, CommandHandlerFunctionV1, CommandHandlerFunctionV2, CommandObject, CommandTuple, CommandUniversal, ConnectorCallbacks, ConnectorConfig, ConnectorParent, ConsolaAdapterOptions, ConsoleHandlerOptions, CrmItemDelivery, CrmItemPayment, CrmItemProductRow, Currency, CurrencyFormat, CustomRefreshAuth, EventHandlerParams, EventOnAppInstallHandlerParams, EventOnAppUnInstallHandlerParams, Fields, Formatter, GenderString, GetPayload, Handler, HandlerAuthParams, HandlerOptions, HandlerRefreshAuth, IB24BatchOptions, ICallBatchOptions, ICallBatchResult, ILimiter, IPlacementUF, IRequestIdGenerator, IResult, ISODate, JsonRpcRequest, ListPayload, LogLevelName, LogRecord, LoggerInterface, MemoryHandlerOptions, MessageInitData, MultiField, MultiFieldArray, NumberString, OperatingLimitConfig, Payload, PayloadOAuthToken, PayloadTime, PlacementViewMode, Processor, RateLimitConfig, RefreshAuthData, RestrictionManagerStats, RestrictionParams, RpcCommand, RpcCommandResult, RpcError, RpcRequest, SdkErrorDetails, SelectCRMParams, SelectCRMParamsEntityType, SelectCRMParamsValue, SelectedAccess, SelectedCRM, SelectedCRMEntity, SelectedUser, SendParams, SharedConfigCallbacks, SharedConfigParams, StatusClose, StorageManagerParams, StreamHandlerOptions, SuccessPayload, TelegramHandlerOptions, TextType, TypeApp, TypeB24, TypeB24Form, TypeCallParams, TypeChanel, TypeChannelManagerParams, TypeConnector, TypeDescriptionError, TypeDescriptionErrorV3, TypeEnumAppStatus, TypeHttp, TypeJsonRpcConfig, TypeLicense, TypePayment, TypePublicIdDescriptor, TypePullClientConfig, TypePullClientEmitConfig, TypePullClientMessageBatch, TypePullClientMessageBody, TypePullClientParams, TypePullClientSession, TypePullMessage, TypeRpcResponseAwaiters, TypeSessionEvent, TypeStorageManager, TypeSubscriptionCommandHandler, TypeSubscriptionOptions, TypeUser, UserBasic, UserBrief, UserFieldType, UserStatusCallback, WinstonAdapterOptions };