bx-rest 1.5.0 → 1.5.1

package/fesm2022/bx-rest.mjs

@@ -1,12 +1,11 @@
+import { Subscription, of, throwError, from, defer, forkJoin, concatMap, toArray, mergeMap, shareReplay, tap } from 'rxjs';
 import { switchMap, catchError, map, take, mergeMap as mergeMap$1 } from 'rxjs/operators';
-import { Subscription, of, throwError, from, defer, forkJoin, last, shareReplay, mergeMap, concatMap, toArray, map as map$1, tap } from 'rxjs';
 import clone from 'just-clone';
 import axios from 'axios';
 import flatten from 'just-flatten-it';
 import { stringify } from 'qs-esm';
 import values from 'just-values';
 import camelCase from 'just-camel-case';
-import { __decorate } from 'tslib';
 
 const DEFAULT_BX_REST_SETTINGS = {
     auth: {
@@ -55,7 +54,9 @@ function BXRestMapResult(v) {
     return undefined;
 }
 function instanceOfiBXRestAnswerSuccess(object) {
-    return 'result' in object;
+    // Без проверки типа `in` бросает TypeError на строке, числе и null вместо false.
+    // Строка приходит, если вместо Bitrix ответил прокси: HTML axios отдаёт текстом
+    return typeof object === 'object' && object !== null && 'result' in object;
 }
 
 function toLocalAtom(date) {
@@ -215,8 +216,12 @@ function parseDateWithFormat(val, format) {
     if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59 || second > 59) {
         return null;
     }
+    return buildDate(year, month, day, hour, minute, second);
+}
+/** Собирает дату, отбрасывая несуществующие дни месяца: new Date() превратил бы 31 февраля в 3 марта. */
+function buildDate(year, month, day, hour, minute, second) {
     const date = new Date(year, month - 1, day, hour, minute, second);
-    return isNaN(date.getTime()) ? null : date;
+    return (isNaN(date.getTime()) || date.getMonth() !== month - 1 || date.getDate() !== day) ? null : date;
 }
 /**
  * Последний резервный разбор — без знания конкретного формата. Работает только для чисто
@@ -259,8 +264,7 @@ function parseDateHeuristically(val) {
     if (hour > 23 || minute > 59 || second > 59) {
         return null;
     }
-    const date = new Date(year, month - 1, day, hour, minute, second);
-    return isNaN(date.getTime()) ? null : date;
+    return buildDate(year, month, day, hour, minute, second);
 }
 /**
  * Преобразует значение в дату.
@@ -1203,6 +1207,7 @@ class HttpBXServices extends HttpServices {
                     // Преобразуем параметры в формат x-www-form-urlencoded
                     const bodyString = this.serializeBitrixParams(paramsClone);
                     return from(this.axiosInstance.post(fullUrl, bodyString, {
+                        withCredentials: this.session.getWithCredentials(),
                         headers: this.buildHeaders(headers, { 'Content-Type': 'application/x-www-form-urlencoded' }),
                     }).then((response) => response.data));
                 }
@@ -1221,22 +1226,26 @@ class HttpBXServices extends HttpServices {
         // авторизации — как в httpPost.
         return withAuthRefresh(defer(() => {
             const paramsClone = clone(params);
+            const key = this.session.getKeyAuth();
             const auth = this.session.getAuthParams();
             const checkIsOn = this.session.getCheckAuthParamsIsOn();
             if (checkIsOn) {
                 if (!auth) {
                     return throwError(() => this.session.getAuthError('get'));
                 }
-                paramsClone[this.session.getKeyAuth()] = auth;
+                if (key !== 'OAuth2') {
+                    paramsClone[key] = auth;
+                }
             }
             return this.session.getBaseUrl().pipe(switchMap((baseUrl) => {
                 if (!baseUrl) {
                     return throwError(() => this.session.getBaseUrlError('get'));
                 }
                 const fullUrl = prepareBaseAddress(baseUrl) + url;
-                const queryString = new URLSearchParams(paramsClone).toString();
+                const queryString = this.serializeBitrixParams(paramsClone);
                 const finalUrl = `${fullUrl}?${queryString}`;
                 return from(this.axiosInstance.get(finalUrl, {
+                    withCredentials: this.session.getWithCredentials(),
                     headers: this.buildHeaders(headers),
                 }).then((response) => response.data));
             }));
@@ -1259,6 +1268,19 @@ class HttpBXServices extends HttpServices {
     }
 }
 
+/** Больше команд в одном запросе `batch` Bitrix не принимает. */
+const BATCH_COMMANDS_LIMIT = 50;
+/**
+ * Параметры остальных страниц для методов с постраничной навигацией через `start`.
+ * Отсчёт идёт от `start` самого запроса: первая страница уже получена именно с него.
+ */
+function offsetPageParams(param, total, pageSize) {
+    const pages = [];
+    for (let start = (Number(param?.start) || 0) + pageSize; start < (total ?? 0); start += pageSize) {
+        pages.push({ ...clone(param), start });
+    }
+    return pages;
+}
 class NavvyPagBase {
     constructor(url, param, map = undefined, restApi = false) {
         this.url = url;
@@ -1302,13 +1324,7 @@ class NavvyPagBase {
     }
     mapAndError(request, options) {
         const method = this.http.getNameMethod(this.url);
-        return request.pipe(map(v => {
-            if (options?.throwOnApiError && v && !instanceOfiBXRestAnswerSuccess(v)) {
-                throw this.apiErrorFromBody(v);
-            }
-            return BXRestMapResult(v);
-        }), catchError((err) => {
-            console.error(err);
+        return request.pipe(catchError((err) => {
             if (err instanceof BXRestApiError) {
                 throw err;
             }
@@ -1328,6 +1344,14 @@ class NavvyPagBase {
                 Object.assign(error, { authRefreshError });
             }
             throw error;
+        }), map(v => {
+            if (v && typeof v !== 'object') {
+                throw this.notRestAnswerError();
+            }
+            if (options?.throwOnApiError && v && !instanceOfiBXRestAnswerSuccess(v)) {
+                throw this.apiErrorFromBody(v);
+            }
+            return BXRestMapResult(v);
         }));
     }
     /**
@@ -1336,12 +1360,48 @@ class NavvyPagBase {
      */
     resFirstPage() {
         return this.resVanilla().pipe(map(v => {
-            if (v && !instanceOfiBXRestAnswerSuccess(v)) {
+            if (!v || typeof v !== 'object') {
+                throw this.notRestAnswerError();
+            }
+            if (!instanceOfiBXRestAnswerSuccess(v)) {
                 throw this.apiErrorFromBody(v);
             }
             return v;
         }));
     }
+    /**
+     * Остальные страницы для `.resAll()`, в порядке `params`. Команды уходят через `batch`,
+     * пакеты — по очереди. Ошибка любой страницы завершает весь запрос: неполный список
+     * выглядел бы для вызывающего кода как полный.
+     */
+    resPages(params) {
+        const method = this.http.getNameMethod(this.url);
+        const commands = params.map(param => method + '?' + serializeBitrixParams(param));
+        const batches = [];
+        for (let i = 0; i < commands.length; i += BATCH_COMMANDS_LIMIT) {
+            batches.push(commands.slice(i, i + BATCH_COMMANDS_LIMIT));
+        }
+        return from(batches).pipe(concatMap(cmd => this.http.post(['batch'], { halt: 1, cmd }, false, this.requestHeaders)), map(answer => this.batchPages(answer)), toArray(), map(pages => pages.flat()));
+    }
+    batchPages(answer) {
+        if (!answer || typeof answer !== 'object') {
+            throw this.notRestAnswerError();
+        }
+        if (!instanceOfiBXRestAnswerSuccess(answer)) {
+            throw this.apiErrorFromBody(answer);
+        }
+        // Портал отдаёт result_error массивом, когда ошибок нет, и объектом с ключами команд, когда есть
+        const failed = Object.values(answer.result?.result_error ?? {})[0];
+        if (failed) {
+            const parsed = parseBXRestErrorBody(failed);
+            throw new BXRestApiError(parsed?.error, parsed?.error_description, { method: this.http.getNameMethod(this.url) });
+        }
+        return Object.values(answer.result?.result ?? {}).filter(Boolean);
+    }
+    // В тексте ошибки — только метод, без тела ответа: это может быть целая HTML-страница
+    notRestAnswerError() {
+        return new Error(`Bitrix24 answered ${this.http.getNameMethod(this.url)} with a body that is not a REST response.`);
+    }
     apiErrorFromBody(v) {
         const parsed = parseBXRestErrorBody(v);
         return new BXRestApiError(parsed ? parsed.error : v.error, parsed ? parsed.error_description : v.error_description, { method: this.http.getNameMethod(this.url) });
@@ -1351,6 +1411,165 @@ class NavvyPagBase {
 class NavvySimple extends NavvyPagBase {
 }
 
+/**
+ * Класс-прослойка-обработчик для методов работающих на альтернативной постраничной навигации тика как методы по
+ * затраченному времени на задачи https://dev.1c-bitrix.ru/rest_help/tasks/task/elapseditem/index.php
+ *
+ * не завершенный класс, работаем от частного к общему
+ */
+class NavvyAlterPagNav extends NavvyPagBase {
+    resAll() {
+        return this.resFirstPage().pipe(mergeMap(first => this.resPages(first.next ? this.pageParams(first.total) : []).pipe(map(pages => {
+            const items = [first.result ?? [], ...pages].flat();
+            return ((this.map ? this.map(items) : items) ?? []);
+        }))), 
+        // refCount: без подписчиков оставшиеся страницы запрашивать незачем
+        shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    /**
+     * Параметры остальных страниц. Размер страницы берётся из запроса: портал ограничивает
+     * его 50 записями, но вызывающий код может попросить и меньше.
+     */
+    pageParams(total = 0) {
+        const nav = this.param.PARAMS?.NAV_PARAMS;
+        const nPageSize = Math.min(nav?.nPageSize || this.pageSize, this.pageSize);
+        const pages = [];
+        for (let iNumPage = (nav?.iNumPage || 1) + 1; iNumPage <= Math.ceil(total / nPageSize); iNumPage++) {
+            pages.push({ ...clone(this.param), PARAMS: { ...this.param.PARAMS, NAV_PARAMS: { ...nav, nPageSize, iNumPage } } });
+        }
+        return pages;
+    }
+}
+
+class NavvyPagNavWithUselessKey extends NavvyPagBase {
+    resAll() {
+        return this.resFirstPage().pipe(mergeMap(first => {
+            const params = first.next ? offsetPageParams(this.param, first.total, this.pageSize) : [];
+            return this.resPages(params).pipe(map(pages => {
+                const merged = Object.assign({}, first.result, ...pages);
+                return (this.map ? this.map(merged) : [merged]);
+            }));
+        }));
+    }
+}
+
+class NavvyPagNavResultKey extends NavvyPagBase {
+    constructor(url, param, key, map, restApi) {
+        // Без своего map результат — массив по ключу, как и обещают типы `.res()` и `.resAll()`.
+        // Иначе `.res()` отдал бы весь объект `{ items: [...] }`.
+        super(url, param, map ?? (result => (result?.[key] ?? [])), restApi);
+        this.key = key;
+    }
+    resAll() {
+        return this.resFirstPage().pipe(mergeMap(first => this.resPages(offsetPageParams(this.param, first.total, this.pageSize)).pipe(map(pages => {
+            const items = [first.result, ...pages].flatMap(page => page?.[this.key] ?? []);
+            const joined = { ...first.result, [this.key]: items };
+            return (this.map?.(joined) ?? []);
+        }))), 
+        // refCount: без подписчиков оставшиеся страницы запрашивать незачем
+        shareReplay({ bufferSize: 1, refCount: true }));
+    }
+}
+
+class NavvyPagNavTasks extends NavvyPagNavResultKey {
+    constructor(url, param, map, restApi) {
+        super(url, param, 'tasks', map, restApi);
+    }
+}
+
+class NavvyPag extends NavvyPagBase {
+    resAll() {
+        return this.resFirstPage().pipe(mergeMap(first => this.resPages(offsetPageParams(this.param, first.total, this.pageSize)).pipe(map(pages => {
+            const items = [first.result ?? [], ...pages].flat();
+            return ((this.map ? this.map(items) : items) ?? []);
+        }))));
+    }
+}
+
+/** Пагинация для методов, возвращающих коллекцию как объект с идентификаторами в ключах. */
+class NavvyPagNavResultKeyObject extends NavvyPagBase {
+    constructor(url, param, key, mapResult) {
+        // Без своего map результат — значения объекта по ключу, как и обещают типы `.res()` и `.resAll()`.
+        super(url, param, mapResult ?? (result => Object.values(result?.[key] ?? {})));
+        this.key = key;
+    }
+    resAll() {
+        return this.resFirstPage().pipe(mergeMap(first => this.resPages(offsetPageParams(this.param, first.total, this.pageSize)).pipe(map(pages => {
+            const merged = Object.assign({}, first.result?.[this.key], ...pages.map(page => page[this.key]));
+            return this.map?.({ ...first.result, [this.key]: merged });
+        }))), 
+        // refCount: без подписчиков оставшиеся страницы запрашивать незачем
+        shareReplay({ bufferSize: 1, refCount: true }));
+    }
+}
+
+class NavvySupport {
+    constructor(requestClass) {
+        this.requestClass = requestClass;
+        this.pageSize = 50; // стандартный размер страницы
+    }
+    mapAndError(request) {
+        return request.pipe(map(v => BXRestMapResult(v)), catchError((err) => {
+            console.error(err);
+            throw new Error((err.error) ? err.error : err);
+        }));
+    }
+}
+
+class Navvy {
+    simple(url, arg, map) {
+        return new NavvySimple(url, arg !== undefined ? arg : undefined, map);
+    }
+    simpleV3(url, arg, map) {
+        return new NavvySimple(url, arg !== undefined ? arg : undefined, map, true);
+    }
+    /**
+     * Новый, пока тестируемый метод для api методов с пагинацией
+     *
+     * @param url
+     * @param arg
+     * @param map
+     * @constructor
+     */
+    pagNav(url, arg, map) {
+        return new NavvyPag(url, arg, map);
+    }
+    // old PagNav
+    // PagNav<T, R, A extends iBXRestPagination>(
+    //   func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
+    //   arg: A,
+    //   map: ((param: T[] | undefined) => R[] | undefined) | undefined) {
+    //   return new NavvyPagNav(this.requestClass, this.mapClass, func, arg, map)
+    // }
+    // Batch<T, R, A extends iBXRestPagination>(
+    //   func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
+    //   arg: A,
+    //   map: ((param: T[] | undefined) => R[] | undefined) | undefined) {
+    //   return new NavvyBatch(this.requestClass, this.mapClass, func, arg, map)
+    // }
+    pagNavTasks(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<{tasks: T[] | undefined}> | undefined>,
+    arg, map) {
+        return new NavvyPagNavTasks(url, arg, map);
+    }
+    pagNavResultKey(url, arg, key, map) {
+        return new NavvyPagNavResultKey(url, arg, key, map);
+    }
+    pagNavResultKeyObject(url, arg, key, map) {
+        return new NavvyPagNavResultKeyObject(url, arg, key, map);
+    }
+    pagNavWithUselessKey(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<{ [key: string]: T }> | undefined>,
+    arg, map) {
+        return new NavvyPagNavWithUselessKey(url, arg, map);
+    }
+    alterPagNav(url, 
+    // func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
+    arg, map) {
+        return new NavvyAlterPagNav(url, arg, map);
+    }
+}
+
 const $get = 'get';
 const $add = 'add';
 const $set = 'set';
@@ -2242,1517 +2461,201 @@ var partNameMethods$1 = /*#__PURE__*/Object.freeze({
     $priceTypeGroup: $priceTypeGroup,
     $priceTypeLang: $priceTypeLang,
     $product: $product,
-    $productImage: $productImage,
-    $productProperty: $productProperty,
-    $productPropertyEnum: $productPropertyEnum,
-    $productPropertyFeature: $productPropertyFeature,
-    $productPropertySection: $productPropertySection,
-    $productrow: $productrow,
-    $productrows: $productrows,
-    $property: $property,
-    $propertyGroup: $propertyGroup,
-    $propertyRelation: $propertyRelation,
-    $propertyValue: $propertyValue,
-    $propertyVariant: $propertyVariant,
-    $provider: $provider,
-    $public: $public,
-    $publication: $publication,
-    $publicationFolder: $publicationFolder,
-    $pull: $pull,
-    $quick: $quick,
-    $quote: $quote,
-    $ratio: $ratio,
-    $reaction: $reaction,
-    $read: $read,
-    $reading: $reading,
-    $recall: $recall,
-    $recent: $recent,
-    $recipient: $recipient,
-    $record: $record,
-    $recurring: $recurring,
-    $region: $region,
-    $register: $register,
-    $remove: $remove,
-    $removeAttachments: $removeAttachments,
-    $removeCard: $removeCard,
-    $removeEntities: $removeEntities,
-    $removecrmactivity: $removecrmactivity,
-    $rename: $rename,
-    $renew: $renew,
-    $reply: $reply,
-    $repo: $repo,
-    $report: $report,
-    $reports: $reports,
-    $repowidget: $repowidget,
-    $request: $request,
-    $requisite: $requisite,
-    $reset: $reset,
-    $resolveIdByPublicUrl: $resolveIdByPublicUrl,
-    $resource: $resource,
-    $resourcetype: $resourcetype,
-    $restore: $restore,
-    $restoreFromVersion: $restoreFromVersion,
-    $result: $result,
-    $resume: $resume,
-    $revision: $revision,
-    $rights: $rights,
-    $robot: $robot,
-    $role: $role,
-    $roundingRule: $roundingRule,
-    $sale: $sale,
-    $save: $save,
-    $schedule: $schedule,
-    $schema: $schema,
-    $search: $search,
-    $searchCrmEntities: $searchCrmEntities,
-    $section: $section,
-    $send: $send,
-    $sendContext: $sendContext,
-    $sendMessage: $sendMessage,
-    $sender: $sender,
-    $senders: $senders,
-    $server: $server,
-    $service: $service,
-    $session: $session,
-    $set: $set,
-    $setAccessCodes: $setAccessCodes,
-    $setDelivery: $setDelivery,
-    $setLandingRef: $setLandingRef,
-    $setOwner: $setOwner,
-    $setQuantity: $setQuantity,
-    $setRights: $setRights,
-    $setSiteRef: $setSiteRef,
-    $setowner: $setowner,
-    $settings: $settings,
-    $share: $share,
-    $sharetouser: $sharetouser,
-    $shipment: $shipment,
-    $shipmentItem: $shipmentItem,
-    $shipmentProperty: $shipmentProperty,
-    $shipmentPropertyValue: $shipmentPropertyValue,
-    $show: $show,
-    $showBlock: $showBlock,
-    $sign: $sign,
-    $silent: $silent,
-    $sip: $sip,
-    $site: $site,
-    $skip: $skip,
-    $sku: $sku,
-    $slots: $slots,
-    $socialnetwork: $socialnetwork,
-    $sonet_group: $sonet_group,
-    $source: $source,
-    $spam: $spam,
-    $stagehistory: $stagehistory,
-    $stages: $stages,
-    $start: $start,
-    $startwatch: $startwatch,
-    $startwithsound: $startwithsound,
-    $startwithtext: $startwithtext,
-    $statistic: $statistic,
-    $status: $status,
-    $statusLang: $statusLang,
-    $statuslist: $statuslist,
-    $stop: $stop,
-    $stopwatch: $stopwatch,
-    $storage: $storage,
-    $store: $store,
-    $storeProduct: $storeProduct,
-    $subscribe: $subscribe,
-    $syspage: $syspage,
-    $system: $system,
-    $tail: $tail,
-    $task: $task,
-    $tasks: $tasks,
-    $telephony: $telephony,
-    $template: $template,
-    $terminate: $terminate,
-    $text: $text,
-    $textField: $textField,
-    $thread: $thread,
-    $time: $time,
-    $timeMan: $timeMan,
-    $timecontrol: $timecontrol,
-    $timeline: $timeline,
-    $todo: $todo,
-    $trace: $trace,
-    $tracking: $tracking,
-    $tradeBinding: $tradeBinding,
-    $tradePlatform: $tradePlatform,
-    $transfer: $transfer,
-    $tree: $tree,
-    $trigger: $trigger,
-    $tts: $tts,
-    $type: $type,
-    $types: $types,
-    $unbind: $unbind,
-    $unbindingFromGroup: $unbindingFromGroup,
-    $unbindingFromMenu: $unbindingFromMenu,
-    $unfavoriteBlock: $unfavoriteBlock,
-    $unmute: $unmute,
-    $unpay: $unpay,
-    $unpin: $unpin,
-    $unpinAll: $unpinAll,
-    $unpublic: $unpublic,
-    $unpublicFolder: $unpublicFolder,
-    $unread: $unread,
-    $unregister: $unregister,
-    $unset: $unset,
-    $unsubscribe: $unsubscribe,
-    $upBlock: $upBlock,
-    $update: $update,
-    $updateAttrs: $updateAttrs,
-    $updateAvatar: $updateAvatar,
-    $updateCards: $updateCards,
-    $updateCatalogProduct: $updateCatalogProduct,
-    $updateColor: $updateColor,
-    $updateContent: $updateContent,
-    $updateDeadline: $updateDeadline,
-    $updateDescription: $updateDescription,
-    $updateFolder: $updateFolder,
-    $updateNodes: $updateNodes,
-    $updateResponsibleUser: $updateResponsibleUser,
-    $updateStyles: $updateStyles,
-    $updateTitle: $updateTitle,
-    $upload: $upload,
-    $uploadFile: $uploadFile,
-    $uploadfile: $uploadfile,
-    $uploadversion: $uploadversion,
-    $url: $url,
-    $user: $user,
-    $userconsent: $userconsent,
-    $userfield: $userfield,
-    $userfieldtype: $userfieldtype,
-    $users: $users,
-    $v1: $v1,
-    $v2: $v2,
-    $vat: $vat,
-    $version: $version,
-    $voices: $voices,
-    $volatileType: $volatileType,
-    $vote: $vote,
-    $voximplant: $voximplant,
-    $waitlist: $waitlist,
-    $workflow: $workflow,
-    $workgroup: $workgroup,
-    $writing: $writing
-});
-
-class BXRestUserUserfield {
-    constructor() {
-        this.url = {
-            list: [$user, $userfield, $list],
-        };
-        this.http = new HttpBXServices();
-    }
-    list() {
-        return this.http.post(this.url.list);
-    }
-}
-
-class BXRestUser {
-    constructor() {
-        this.http = new HttpBXServices();
-        this.userfield = new BXRestUserUserfield();
-        this.url = {
-            admin: [$user, 'admin'],
-            get: [$user, $get],
-            current: [$user, 'current'],
-            update: [$user, $update],
-            search: [$user, $search],
-            access: [$user, 'access'],
-            fields: [$user, 'fields'],
-        };
-    }
-    admin() {
-        return this.http.post(this.url.admin);
-    }
-    get(params = {}) {
-        return this.http.post(this.url.get, params);
-    }
-    current() {
-        return this.http.post(this.url.current, {});
-    }
-    update(user) {
-        return this.http.post(this.url.update, user);
-    }
-    search(params) {
-        return this.http.post(this.url.search, params);
-    }
-    access(access) {
-        return this.http.post(this.url.access, { ACCESS: access });
-    }
-    fields() {
-        return this.http.post(this.url.fields);
-    }
-}
-
-class BXRestListsElement {
-    constructor() {
-        this.url = {
-            add: [$lists, $element, $add],
-            get: [$lists, $element, $get],
-        };
-        this.http = new HttpBXServices();
-    }
-    get(pram) {
-        return this.http.post(this.url.get, pram);
-    }
-    add(param) {
-        return this.http.post(this.url.add, param);
-    }
-}
-
-class BXRestListsField {
-    constructor() {
-        this.url = {
-            // /**
-            //  * Метод создает поле списка
-            //  */
-            // add: [$lists, $field, $add],
-            // /**
-            //  * Метод удаляет поле списка
-            //  */
-            // delete: [$lists, $field, $delete],
-            /**
-             * Метод возвращает данные поля
-             */
-            get: [$lists, $field, $get],
-            // type: {
-            //   /**
-            //    * Метод возвращает доступные типа полей для указанного списка
-            //    */
-            //   get: [$lists, $field, $type, $get],
-            // },
-            // /**
-            //  * Метод обновляет поле списка
-            //  */
-            // update: [$lists, $field, $update],
-        };
-        this.http = new HttpBXServices();
-    }
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-}
-
-class BXRestLists {
-    constructor() {
-        this.url = {
-            // /**
-            //  * Метод создаёт список
-            //  */
-            // add: [$lists, $add],
-            // /**
-            //  * Метод удаляет список
-            //  */
-            // delete: [$lists, $delete],
-            /**
-             * Метод возвращает данные по спискам
-             */
-            get: [$lists, $get],
-            // /**
-            //  * Метод обновляет существующий список
-            //  */
-            // update: [$lists, $update],
-            // /**
-            //  * Метод возвращает id типа инфоблока
-            //  */
-            // getIBlockTypeId: [$lists, $get, $iblock, $type, $id],
-            element: {
-                /**
-                 * Метод создаёт элемент списка
-                 */
-                add: [$lists, $element, $add],
-                // /**
-                //  * Метод удаляет элемент списка TODO: Реализовать
-                //  */
-                // delete: [$lists, $element, $delete],
-                /**
-                 * Метод возвращает список элементов или элемент
-                 */
-                get: [$lists, $element, $get],
-                // /**
-                //  * Метод обновляет элемент списка TODO: Реализовать
-                //  */
-                // update: [$lists, $element, $update],
-                // /**
-                //  * Метод возвращает путь к файлу TODO: Реализовать
-                //  */
-                // getFileUrl: [$lists, $element, $get, $file, $url]
-            },
-            field: {
-                // /**
-                //  * Метод создает поле списка
-                //  */
-                // add: [$lists, $field, $add],
-                // /**
-                //  * Метод удаляет поле списка
-                //  */
-                // delete: [$lists, $field, $delete],
-                /**
-                 * Метод возвращает данные поля
-                 */
-                get: [$lists, $field, $get],
-                // type: {
-                //   /**
-                //    * Метод возвращает доступные типа полей для указанного списка
-                //    */
-                //   get: [$lists, $field, $type, $get],
-                // },
-                // /**
-                //  * Метод обновляет поле списка
-                //  */
-                // update: [$lists, $field, $update],
-            }
-        };
-        this.element = new BXRestListsElement();
-        this.field = new BXRestListsField();
-        this.http = new HttpBXServices();
-    }
-    // getField(pram: getListFieldParam): Observable<iHttpAnswerBX<FieldItemLists[]> | undefined> {
-    //     return this.http.post<iHttpAnswerBX<{ [key: string]: FieldItemLists }>>(this.url.field.get, pram)
-    // }
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-}
-
-class BXRestTaskElapsedItem {
-    constructor() {
-        this.url = {
-            getList: [$task, $elapseditem, $getlist],
-            add: [$task, $elapseditem, $add],
-            delete: [$task, $elapseditem, $delete],
-            isActionAllowed: [$task, $elapseditem, $isactionallowed],
-            update: [$task, $elapseditem, $update],
-        };
-        this.http = new HttpBXServices();
-    }
-    getList(param = {}) {
-        return this.http.post(this.url.getList, param);
-    }
-    add(param) {
-        return this.http.post(this.url.add, param);
-    }
-    update(param) {
-        return this.http.post(this.url.update, param);
-    }
-    del(param) {
-        return this.http.post(this.url.delete, param);
-    }
-    /**
-     * idAction:
-     * 1 - ACTION_ELAPSED_TIME_ADD
-     * 2 - ACTION_ELAPSED_TIME_MODIFY
-     * 3 - ACTION_ELAPSED_TIME_REMOVE
-     * ITEMID - обязателен в конечной отправке но не обязателен для ACTION_ELAPSED_TIME_ADD,
-     * поэтому этом методе можно ставить "1" например, так же метод может выдавать ошибки о не доступности задачи
-     * поэтому рекомендую воспользоваться аналогичным методом в пространстве имен navvy
-     * @param param
-     */
-    isActionAllowed(param) {
-        return this.http.post(this.url.isActionAllowed, param);
-    }
-}
-
-class BXRestTaskCommentItem {
-    constructor() {
-        this.url = {
-            getManifest: [$task, $commentitem, $getmanifest], // Возвращает список методов и их описание
-            getList: [$task, $commentitem, $getlist], // Возвращает список комментариев к задаче
-            get: [$task, $commentitem, $get], // Возвращает комментарий к задаче
-            add: [$task, $commentitem, $add], // Создает новый комментарий к задаче
-            update: [$task, $commentitem, $update], // Обновляет данные комментария
-            delete: [$task, $commentitem, $delete], // Удаляет комментарий
-            isActionAllowed: [$task, $commentitem, $isactionallowed], // Проверяет, разрешено ли действие
-        };
-        this.http = new HttpBXServices();
-    }
-    add(param) {
-        return this.http.post(this.url.add, param);
-    }
-    update(param) {
-        return this.http.post(this.url.update, param);
-    }
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-    getlist(param) {
-        return this.http.post(this.url.getList, param);
-    }
-    del(param) {
-        return this.http.post(this.url.delete, param);
-    }
-}
-
-class BXRestTaskPlanner {
-    constructor() {
-        this.http = new HttpBXServices();
-    }
-    getList() {
-        return this.http.post([$task, $planner, $getlist]);
-    }
-}
-
-class BXRestTaskItemUserField {
-    constructor() {
-        this.url = {
-            getList: [$task, $item, $userfield, 'getlist'],
-        };
-        this.http = new HttpBXServices();
-    }
-    getList(param) {
-        return this.http.post(this.url.getList, param);
-    }
-}
-
-class BXRestTaskItem {
-    constructor() {
-        this.userField = new BXRestTaskItemUserField();
-    }
-}
-
-class BXRestTask {
-    constructor() {
-        this.elapsedItem = new BXRestTaskElapsedItem();
-        this.commentItem = new BXRestTaskCommentItem();
-        this.planner = new BXRestTaskPlanner();
-        this.item = new BXRestTaskItem();
-    }
-}
-
-class BXRestTasksTaskResult {
-    constructor() {
-        this.url = {
-            list: [$tasks, $task, $result, $list],
-            addFromComment: [$tasks, $task, $result, 'addFromComment'],
-            deleteFromComment: [$tasks, $task, $result, 'deleteFromComment'],
-        };
-        this.http = new HttpBXServices();
-    }
-    deleteFromComment(commentID) {
-        return this.http.post(this.url.deleteFromComment, { commentId: commentID });
-    }
-    addFromComment(param) {
-        return this.http.post(this.url.addFromComment, param);
-    }
-    list(param) {
-        return this.http.post(this.url.list, param);
-    }
-}
-
-class BXRestTasksTask {
-    constructor() {
-        this.url = {
-            add: [$tasks, $task, $add],
-            approve: [$tasks, $task, $approve],
-            complete: [$tasks, $task, $complete],
-            defer: [$tasks, $task, $defer],
-            get: [$tasks, $task, $get],
-            getFields: [$tasks, $task, $getFields],
-            getAccess: [$tasks, $task, $getaccess],
-            list: [$tasks, $task, $list],
-            update: [$tasks, $task, $update],
-        };
-        this.result = new BXRestTasksTaskResult();
-        this.http = new HttpBXServices();
-    }
-    add(param) {
-        return this.http.post(this.url.add, param);
-    }
-    approve(param) {
-        return this.http.post(this.url.approve, param);
-    }
-    complete(param) {
-        return this.http.post(this.url.complete, param);
-    }
-    defer(param) {
-        return this.http.post(this.url.defer, param);
-    }
-    update(param) {
-        return this.http.post(this.url.update, param);
-    }
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-    list(param) {
-        return this.http.post(this.url.list, param);
-    }
-    /*
-    listArray(requestArray: RequestApiTaskListBX = {}) {
-      return this.list(requestArray).pipe(
-        map(v => this.http.mapResult(v)),
-        map(v => (v && v.tasks) ? v.tasks : [])
-      )
-    }
-  
-    listAll(requestArray: RequestApiTaskListBX = {}, cache = false): Observable<TaskBX[]> {
-      if (!requestArray.select) {
-        requestArray.select = this.def.select
-        if (cache) {
-          return this.storeTask$.pipe(
-            take(1),
-            mergeMap(tasks => {
-              if (tasks && tasks.data.http.list && requestArray.filter && requestArray.filter.ID) {
-                const ids = (typeof requestArray.filter.ID === 'number') ? [requestArray.filter.ID] : requestArray.filter.ID
-                let filter = tasks.data.http.list.filter(i => (i.id) ? ids.includes(i.id) : false)
-                if (filter.length === ids.length) {
-                  return of(filter)
-                }
-              }
-              return this.getEndListArray(requestArray)
-            })
-          )
-        }
-        return this.getEndListArray(requestArray)
-      }
-      return this.getEndListArray(requestArray)
-    }
-  
-    getEndListArray(requestArray: RequestApiTaskListBX): Observable<TaskBX[]> {
-      return this.list(requestArray).pipe(
-        mergeMap((items: AnswerApiTaskBX | undefined): ObservableInput<any> | Observable<AnswerApiTaskBX[]> => {
-          if (items && items.result && typeof items.result.tasks === 'object') {
-            const items$ = of(items.result.tasks)
-            if (items.next) {
-              this.nowLoad$.next({
-                total: (items.total) ? items.total : 0,
-                next: items.next
-              })
-              requestArray.start = items.next
-              return this.getEndListArray(requestArray).pipe(
-                map(vEnd => {
-                  if (vEnd && items.result.tasks) {
-                    return [...items.result.tasks, ...vEnd]
-                  }
-                  return (items.result.tasks) ? items.result.tasks : []
-                }))
-            }
-            this.nowLoad$.next({
-              total: 0,
-              next: 0
-            })
-            return items$
-          } else {
-            return of([])
-          }
-        })
-      )
-    }
-    */
-    getFields() {
-        return this.http.post(this.url.getFields);
-    }
-    getAccess(param) {
-        return this.http.post(this.url.getAccess, param);
-    }
-}
-
-class BXRestTasks {
-    constructor() {
-        this.task = new BXRestTasksTask();
-    }
-}
-
-class BXRestDiskFile {
-    constructor() {
-        this.url = {
-            get: [$disk, $file, $get],
-            markDeleted: [$disk, $file, $markdeleted],
-        };
-        this.http = new HttpBXServices();
-    }
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-    markDeleted(param) {
-        return this.http.post(this.url.markDeleted, param);
-    }
-}
-
-class BXRestDiskFolder {
-    constructor() {
-        this.url = {
-            getFields: [$disk, $folder, $getFields],
-            get: [$disk, $folder, $get],
-            getChildren: [$disk, $folder, $getchildren],
-            addSubFolder: [$disk, $folder, 'addsubfolder'],
-            copyTo: [$disk, $folder, $copyto],
-            moveTo: [$disk, $folder, $moveto],
-            rename: [$disk, $folder, $rename],
-            deleteTree: [$disk, $folder, 'deletetree'],
-            markDeleted: [$disk, $folder, $markdeleted],
-            restore: [$disk, $folder, $restore],
-            uploadFile: [$disk, $folder, $uploadfile],
-            getExternalLink: [$disk, $folder, 'getExternalLink'],
-        };
-        this.http = new HttpBXServices();
-    }
-    /**
-     * Возвращает папку по идентификатору
-     *
-     * @param param
-     */
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-    /**
-     * Создает дочернюю папку
-     *
-     * @param param
-     */
-    addSubFolder(param) {
-        return this.http.post(this.url.addSubFolder, param);
-    }
-    /**
-     * Копирует папку в указанную папку
-     *
-     * @param param
-     */
-    copyTo(param) {
-        return this.http.post(this.url.copyTo, param);
-    }
-    /**
-     * Перемещает папку в указанную папку
-     *
-     * @param param
-     */
-    moveTo(param) {
-        return this.http.post(this.url.moveTo, param);
-    }
-    /**
-     * Переименовывает папку
-     *
-     * @param param
-     */
-    rename(param) {
-        return this.http.post(this.url.rename, param);
-    }
-    /**
-     * Уничтожает папку и всё её дочерние элементы навсегда
-     * В ответе 'result': true - успешное уничтожение папки
-     *
-     * @param param
-     */
-    deleteTree(param) {
-        return this.http.post(this.url.deleteTree, param);
-    }
-    /**
-     * Перемещает папку в корзину
-     *
-     * @param param
-     */
-    markDeleted(param) {
-        return this.http.post(this.url.markDeleted, param);
-    }
-    /**
-     * Восстанавливает папку из корзины
-     *
-     * @param param
-     */
-    restore(param) {
-        return this.http.post(this.url.restore, param);
-    }
-    /**
-     * Метод возвращает публичную ссылку
-     *
-     * @param param
-     */
-    getExternalLink(param) {
-        return this.http.post(this.url.restore, param);
-    }
-    /**
-     * Возвращает описание полей папки
-     */
-    getFields() {
-        return this.http.post(this.url.getFields);
-    }
-    /**
-     * Загружает новый файл в указанную папку
-     *
-     * @param param
-     */
-    uploadFile(param) {
-        return this.http.post(this.url.uploadFile, param);
-    }
-    /**
-     * Возвращает список файлов и папок, которые находятся непосредственно в папке
-     *
-     * @param param
-     */
-    getChildren(param) {
-        return this.http.post(this.url.getChildren, param);
-    }
-}
-
-class BXRestDiskAttachedObject {
-    constructor() {
-        this.url = {
-            get: [$disk, 'attachedObject', $get],
-        };
-        this.http = new HttpBXServices();
-    }
-    get(param) {
-        return this.http.post(this.url.get, param);
-    }
-}
-
-class BXRestDisk {
-    constructor() {
-        this.file = new BXRestDiskFile();
-        this.folder = new BXRestDiskFolder();
-        this.attachedObject = new BXRestDiskAttachedObject();
-    }
-}
-
-class BXRestBizProcWorkflowInstance {
-}
-
-class BXRestBizProcWorkflowTemplate {
-}
-
-class HttpNavvyServices {
-    constructor() {
-        this.httpServices = new HttpBXServices();
-    }
-    // Реализация метода
-    post(url, params) {
-        if (params === undefined) {
-            params = {};
-        }
-        return this.httpServices.post(url, params);
-    }
-}
-
-class BXRestBizProcWorkflow {
-    constructor() {
-        this.instances = new BXRestBizProcWorkflowInstance();
-        this.template = new BXRestBizProcWorkflowTemplate();
-        this.http = new HttpNavvyServices();
-    }
-    /**
-     * Запускает Бизнес-процесс
-     */
-    start(param) {
-        return this.http.post([$bizproc, $workflow, $start], param);
-    }
-}
-
-class BXRestBizProcActivity {
-}
-
-class BXRestBizProcTask {
-}
-
-class BXRestBizProcRobot {
-}
-
-class BXRestBizProcEvent {
-}
-
-class BXRestBizProc {
-    constructor() {
-        this.workflow = new BXRestBizProcWorkflow();
-        this.activity = new BXRestBizProcActivity();
-        this.task = new BXRestBizProcTask();
-        this.robot = new BXRestBizProcRobot();
-        this.event = new BXRestBizProcEvent();
-    }
-}
-
-class BXRestLogBlogPost {
-    constructor() {
-        this.url = {
-            add: [$log, $blogpost, $add],
-            get: [$log, $blogpost, $get],
-        };
-        this.http = new HttpBXServices();
-    }
-    add(param) {
-        return this.http.post(this.url.add, param);
-    }
-    get(param = {}) {
-        return this.http.post(this.url.get, param);
-    }
-}
-
-class BXRestLogBlogComment {
-}
-
-class BXRestLog {
-    constructor() {
-        this.blogPost = new BXRestLogBlogPost();
-        this.blogComment = new BXRestLogBlogComment();
-    }
-}
-
-class BXRestSonetGroup {
-    constructor() {
-        this.url = {
-            get: [$sonet_group, $get],
-        };
-        this.http = new HttpBXServices();
-    }
-    // // TODO: filter и select позже нормально описать
-    // getList(filter: any = {}, select: iWorkgroupFields[] = ['ID', 'NAME']){
-    //   return this.httpPost<iHttpAnswerBX<{workgroups: iListWorkgroup[]}>>(
-    //     this.url.get,
-    //     {
-    //       order: select,
-    //       filter: filter
-    //     }
-    //   )
-    // }
-    get(param = {}) {
-        return this.http.post(this.url.get, param);
-    }
-}
-
-class BXRestServer {
-    constructor() {
-        this.http = new HttpBXServices();
-        this.url = {
-            time: [$server, $time],
-        };
-    }
-    time() {
-        return this.http.post(this.url.time);
-    }
-}
-
-class BXRestDepartment {
-    constructor() {
-        this.url = {
-            get: [$department, $get],
-            del: [$department, $delete],
-            add: [$department, $add],
-            update: [$department, $update],
-        };
-        this.http = new HttpBXServices();
-    }
-    get(param = {}) {
-        return this.http.post(this.url.get, param);
-    }
-    add(param) {
-        return this.http.post(this.url.add, param);
-    }
-    del(param) {
-        return this.http.post(this.url.del, param);
-    }
-    update(param) {
-        return this.http.post(this.url.update, param);
-    }
-}
-
-class BXRestApp {
-    constructor() {
-        this.http = new HttpBXServices();
-    }
-    /**
-     * Показ информации о приложении. Метод поддерживает безопасный вызов
-     */
-    info() {
-        return this.http.post(['app', 'info']);
-    }
-}
-
-class BXRestSocialNetWorkApiContentView {
-    constructor() {
-        this.url = {
-            set: [$socialnetwork, $api, 'contentView', $set],
-        };
-        this.http = new HttpBXServices();
-    }
-    set(param) {
-        return this.http.post(this.url.set, param);
-    }
-}
-
-class BXRestSocialNetWorkApiLiveFeedBlogPostImportant {
-    constructor() {
-        this.url = {
-            vote: [$socialnetwork, $api, 'liveFeed', 'blogPost', 'important', 'vote'],
-        };
-        this.http = new HttpBXServices();
-    }
-    vote(param) {
-        return this.http.post(this.url.vote, param);
-    }
-}
-
-class BXRestSocialNetWorkApiLiveFeedBlogPost {
-    constructor() {
-        this.important = new BXRestSocialNetWorkApiLiveFeedBlogPostImportant();
-    }
-}
-
-class BXRestSocialNetWorkApiLiveFeed {
-    constructor() {
-        this.blogPost = new BXRestSocialNetWorkApiLiveFeedBlogPost();
-    }
-}
-
-class BXRestSocialNetWorkApi {
-    constructor() {
-        this.contentView = new BXRestSocialNetWorkApiContentView();
-        this.liveFeed = new BXRestSocialNetWorkApiLiveFeed();
-    }
-}
-
-class BXRestSocialNetWork {
-    constructor() {
-        // private http = new HttpBXServices)
-        this.api = new BXRestSocialNetWorkApi();
-    }
-}
-
-class BXRestPullApplicationConfig {
-    constructor() {
-        this.http = new HttpBXServices();
-    }
-    get() {
-        return this.http.post([$pull, $application, $config, $get]);
-    }
-}
-
-class BXRestPullConfig {
-    constructor() {
-        this.http = new HttpBXServices();
-        this.config = new BXRestPullApplicationConfig();
-    }
-    get() {
-        return this.http.post([$pull, $config, $get]);
-    }
-}
-
-class BXRestPullChannelPublic {
-    constructor() {
-        this.http = new HttpBXServices();
-        /**
-         * Пес его знает что за метод такой, судя по коду нужно всю инфу json объектом о пользователе передать,
-         * но это не точно
-         */
-        // list() {
-        //   return this.http.post<iBXRestPullChannelPublicGetHttp>([$pull, $channel, $public, $list])
-        // }
-    }
-    get() {
-        return this.http.post([$pull, $channel, $public, $get]);
-    }
-}
-
-class BXRestPull {
-    constructor() {
-        this.config = new BXRestPullConfig();
-        this.channel = {
-            public: new BXRestPullChannelPublic()
-        };
-    }
-}
-
-class BXRest {
-    constructor() {
-        this.http = new HttpBXServices();
-        this.user = new BXRestUser();
-        this.lists = new BXRestLists();
-        this.task = new BXRestTask();
-        this.tasks = new BXRestTasks();
-        this.disk = new BXRestDisk();
-        this.bizProc = new BXRestBizProc();
-        this.log = new BXRestLog();
-        this.sonet_group = new BXRestSonetGroup();
-        this.server = new BXRestServer();
-        this.department = new BXRestDepartment();
-        this.app = new BXRestApp();
-        this.socialNetWork = new BXRestSocialNetWork();
-        this.pull = new BXRestPull();
-    }
-    profile() {
-        return this.http.post(['profile']);
-    }
-    batch(param, headers) {
-        return this.http.post(['batch'], param, false, headers);
-    }
-}
-
-/**
- * Класс-прослойка-обработчик для методов работающих на альтернативной постраничной навигации тика как методы по
- * затраченному времени на задачи https://dev.1c-bitrix.ru/rest_help/tasks/task/elapseditem/index.php
- *
- * не завершенный класс, работаем от частного к общему
- */
-class NavvyAlterPagNav extends NavvyPagBase {
-    resAll() {
-        let save = [];
-        return this.resultAllEnd()
-            .pipe(map(v => {
-            if (v) {
-                save.push(...v);
-            }
-            return save;
-        }), last(), shareReplay(1));
-    }
-    resultAllEnd() {
-        let BXRestClass = new BXRest();
-        // return  this.mapForVanillaEnd(this.func, this.param)
-        return this.resFirstPage().pipe(mergeMap(items => {
-            if (items && instanceOfiBXRestAnswerSuccess(items)) {
-                if (items.total && items.next) {
-                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
-                    // Разделяем массив на блоки
-                    const chunks = [];
-                    for (let i = 0; i < count.length; i += this.pageSize) {
-                        chunks.push(count.slice(i, i + this.pageSize));
-                    }
-                    const batchRequests = chunks.map(chunk => {
-                        return BXRestClass.batch({
-                            halt: 1,
-                            cmd: chunk.map(i => {
-                                const param = clone(this.param);
-                                if (!param.PARAMS) {
-                                    param.PARAMS = {
-                                        NAV_PARAMS: {
-                                            iNumPage: 0,
-                                            nPageSize: 50
-                                        }
-                                    };
-                                }
-                                // Устанавливаем start в зависимости от индекса
-                                param.PARAMS.NAV_PARAMS.iNumPage = i + 2; // первая страница уже есть, старт со второй
-                                // Формируем строку запроса
-                                return this.http.getNameMethod(this.url)
-                                    + '?' + serializeBitrixParams(param);
-                            })
-                        }, this.requestHeaders);
-                    });
-                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
-                    toArray(), // Собирает все результаты в массив
-                    map(results => {
-                        const res = items.result;
-                        for (let result of results) {
-                            if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
-                                res.push(...result.result.result.map(i => i).flat());
-                            }
-                        }
-                        return (this.map) ?
-                            this.map(res)
-                            : res;
-                    }));
-                }
-            }
-            return this.mapResultForGetAll(items);
-        }), catchError(err => {
-            // this.snackBar.error("Проблемы с поточным получение затреканого времени")
-            console.error(err);
-            return throwError(() => err);
-        }));
-    }
-    mapResultForGetAll(items) {
-        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
-    }
-}
-
-class NavvyPagNavWithUselessKey extends NavvyPagBase {
-    constructor() {
-        super(...arguments);
-        this.save = [];
-    }
-    resAll() {
-        let BXRestClass = new BXRest();
-        return this.resFirstPage().pipe(mergeMap(items => {
-            if (items && instanceOfiBXRestAnswerSuccess(items)) {
-                if (items.total && items.next) {
-                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
-                    // Разделяем массив на блоки
-                    const chunks = [];
-                    for (let i = 0; i < count.length; i += this.pageSize) {
-                        chunks.push(count.slice(i, i + this.pageSize));
-                    }
-                    const batchRequests = chunks.map(chunk => {
-                        return BXRestClass.batch({
-                            halt: 1,
-                            cmd: chunk.map(i => {
-                                const param = clone(this.param);
-                                // Устанавливаем start в зависимости от индекса
-                                param.start = (i + 1) * this.pageSize;
-                                // Формируем строку запроса
-                                return this.http.getNameMethod(this.url)
-                                    + '?' + serializeBitrixParams(param);
-                            })
-                        }, this.requestHeaders).pipe(map(v => {
-                            if (v && instanceOfiBXRestAnswerSuccess(v) && v.result && v.result.result && items.result) {
-                                return Object.assign({}, items.result, v.result.result);
-                            }
-                            throw new Error('wrong batch');
-                        }));
-                    });
-                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
-                    toArray()); // Собирает все результаты в массив
-                    /*
-                    return this.getAllTaskElapsedItem(func, param).pipe(
-                      map(vEnd => {
-                        if (vEnd && vEnd.result && items.result) {
-                          return merge(clone(vEnd), {result: [...items.result, ...vEnd.result]})
-                        }
-                        return items
-                      })
-                    )
-                     */
-                }
-                else {
-                    return of([items.result]);
-                }
-            }
-            return of(undefined);
-            // return from([BXRestMapResult(items)])
-            // as ReturnType<Observable<T | undefined>, Observable<R | undefined>>
-        }), map(v => {
-            if (v) {
-                const mergedObject = v.reduce((acc, obj) => {
-                    return { ...acc, ...obj };
-                }, {});
-                if (this.map) {
-                    return this.map(mergedObject);
-                }
-                this.save.push(...v);
-                return this.save;
-            }
-            return v;
-        }), catchError(err => {
-            // this.snackBar.error("Проблемы с поточным получение затреканого времени")
-            console.error(err);
-            return throwError(() => err);
-        }));
-    }
-}
-
-class NavvyPagNavTasks extends NavvyPagBase {
-    constructor(url, param, map, restApi) {
-        // Без своего map результат — массив задач, как и обещают типы `.res()` и `.resAll()`.
-        super(url, param, map ?? (result => (result?.tasks ?? [])), restApi);
-        this.save = [];
-    }
-    resAll() {
-        let save = [];
-        return this.resultAllEnd()
-            .pipe(map(v => {
-            if (v) {
-                save.push(...v);
-            }
-            return save;
-        }), last(), shareReplay(1));
-    }
-    resultAllEnd() {
-        let BXRestClass = new BXRest();
-        return this.resFirstPage().pipe(mergeMap(items => {
-            if (items && instanceOfiBXRestAnswerSuccess(items)) {
-                this.save = [];
-                // TODO: проверить будет ли быстрее работать метод в случаях когда total < 100 (то есть можно обойтись двумя прямыми запросами)
-                if (items.total && items.total > 50) {
-                    const count = [...Array(Math.floor(items.total / this.pageSize)).keys()];
-                    // Разделяем массив на блоки
-                    const chunks = [];
-                    for (let i = 0; i < count.length; i += this.pageSize) {
-                        chunks.push(count.slice(i, i + this.pageSize));
-                    }
-                    const batchRequests = chunks.map(chunk => {
-                        return BXRestClass.batch({
-                            halt: 1,
-                            cmd: chunk.map(i => {
-                                const param = clone(this.param);
-                                // Устанавливаем start в зависимости от индекса
-                                param.start = (i + 1) * this.pageSize;
-                                // Формируем строку запроса
-                                return this.http.getNameMethod(this.url)
-                                    + '?' + serializeBitrixParams(param);
-                            })
-                        }, this.requestHeaders);
-                    });
-                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
-                    toArray(), // Собирает все результаты в массив
-                    map(results => {
-                        if (items.result && items.result.tasks) {
-                            const res = items.result.tasks;
-                            for (let result of results) {
-                                if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
-                                    res.push(...result.result.result.filter(i => i).map(i => i.tasks).flat());
-                                }
-                            }
-                            return (this.map) ?
-                                this.map({ tasks: res })
-                                : res;
-                        }
-                        throw new Error('wrong batch');
-                    }));
-                }
-                return this.mapResForGetAll(items);
-            }
-            return this.mapResForGetAll(items);
-        }), catchError(err => {
-            console.error(err);
-            return throwError(() => err);
-        }));
-    }
-    mapResForGetAll(items) {
-        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
-    }
-}
-
-class NavvyPag extends NavvyPagBase {
-    constructor() {
-        super(...arguments);
-        this.save = [];
-    }
-    resAll() {
-        let BXRestClass = new BXRest();
-        return this.resFirstPage().pipe(mergeMap(items => {
-            if (items && instanceOfiBXRestAnswerSuccess(items)) {
-                this.save = [];
-                // TODO: проверить будет ли быстрее работать метод в случаях когда total < 100 (то есть можно обойтись двумя прямыми запросами)
-                if (items.total && items.total > this.pageSize) {
-                    const mathFloor = Math.floor(items.total / this.pageSize);
-                    const count = (mathFloor === items.total / this.pageSize) // если mathFloor равен обычному делению, значит один запрос будет лишним, так как результат первой страницы уже есть, а последняя в данном случаи будет пустая (или с мусорными аднными)
-                        ? [...Array(mathFloor - 1).keys()]
-                        : [...Array(mathFloor).keys()];
-                    // Разделяем массив на блоки
-                    const chunks = [];
-                    for (let i = 0; i < count.length; i += this.pageSize) {
-                        chunks.push(count.slice(i, i + this.pageSize));
-                    }
-                    const batchRequests = chunks.map(chunk => {
-                        return BXRestClass.batch({
-                            halt: 1,
-                            cmd: chunk.map(i => {
-                                const param = clone(this.param);
-                                // Устанавливаем start в зависимости от индекса
-                                param.start = (i + 1) * this.pageSize;
-                                // Формируем строку запроса
-                                return this.http.getNameMethod(this.url)
-                                    + '?' + serializeBitrixParams(param);
-                            })
-                        }, this.requestHeaders).pipe();
-                    });
-                    return from(batchRequests).pipe(concatMap(request => request), // Выполняет запросы по очереди
-                    toArray(), // Собирает все результаты в массив
-                    map(results => {
-                        const res = items.result;
-                        for (let result of results) {
-                            if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
-                                res.push(...result.result.result.map(i => i).flat());
-                            }
-                        }
-                        return (this.map) ?
-                            this.map(res)
-                            : res;
-                    }));
-                }
-                return this.mapResForGetAll(items);
-            }
-            return this.mapResForGetAll(items);
-        }), map(v => {
-            if (v) {
-                this.save.push(...v);
-            }
-            return this.save;
-        }));
-    }
-    mapResForGetAll(items) {
-        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
-    }
-}
-
-class NavvyPagNavResultKey extends NavvyPagBase {
-    constructor(url, param, key, map) {
-        // Без своего map результат — массив по ключу, как и обещают типы `.res()` и `.resAll()`.
-        // Иначе `.res()` отдал бы весь объект `{ items: [...] }`, а `.resAll()` упал бы на нём
-        // при 50 записях и меньше: первая страница разворачивается через `save.push(...v)`.
-        super(url, param, map ?? (result => (result?.[key] ?? [])));
-        this.key = key;
-        this.save = [];
-    }
-    resAll() {
-        let save = [];
-        return this.resultAllEnd()
-            .pipe(map(v => {
-            if (v) {
-                save.push(...v);
-            }
-            return save;
-        }), last(), shareReplay(1));
-    }
-    resultAllEnd() {
-        let BXRestClass = new BXRest();
-        return this.resFirstPage().pipe(mergeMap(items => {
-            if (items && instanceOfiBXRestAnswerSuccess(items)) {
-                this.save = [];
-                if (items.total && items.total > 50) {
-                    const mathFloor = Math.floor(items.total / this.pageSize);
-                    const count = (mathFloor === items.total / this.pageSize)
-                        ? [...Array(mathFloor - 1).keys()]
-                        : [...Array(mathFloor).keys()];
-                    const chunks = [];
-                    for (let i = 0; i < count.length; i += this.pageSize) {
-                        chunks.push(count.slice(i, i + this.pageSize));
-                    }
-                    const batchRequests = chunks.map(chunk => {
-                        return BXRestClass.batch({
-                            halt: 1,
-                            cmd: chunk.map(i => {
-                                const param = clone(this.param);
-                                param.start = (i + 1) * this.pageSize;
-                                return this.http.getNameMethod(this.url)
-                                    + '?' + serializeBitrixParams(param);
-                            })
-                        }, this.requestHeaders);
-                    });
-                    return from(batchRequests).pipe(concatMap(request => request), toArray(), map(results => {
-                        const firstPage = items.result?.[this.key];
-                        if (firstPage) {
-                            const res = firstPage;
-                            for (let result of results) {
-                                if (result && instanceOfiBXRestAnswerSuccess(result) && result.result && result.result.result) {
-                                    res.push(...result.result.result.filter(i => i).map(i => i[this.key]).flat());
-                                }
-                            }
-                            return (this.map) ?
-                                this.map({ [this.key]: res })
-                                : res;
-                        }
-                        throw new Error('wrong batch');
-                    }));
-                }
-                return this.mapResForGetAll(items);
-            }
-            return this.mapResForGetAll(items);
-        }), catchError(err => {
-            console.error(err);
-            return throwError(() => err);
-        }));
-    }
-    mapResForGetAll(items) {
-        return (instanceOfiBXRestAnswerSuccess(items)) ? from([items.result]).pipe(map(v => (v && this.map) ? this.map(v) : v)) : from([]);
-    }
-}
-
-/** Пагинация для методов, возвращающих коллекцию как объект с идентификаторами в ключах. */
-class NavvyPagNavResultKeyObject extends NavvyPagBase {
-    constructor(url, param, key, mapResult) {
-        // Без своего map результат — значения объекта по ключу, как и обещают типы `.res()` и `.resAll()`.
-        super(url, param, mapResult ?? (result => Object.values(result?.[key] ?? {})));
-        this.key = key;
-    }
-    resAll() {
-        return this.resultAllEnd().pipe(last(), shareReplay(1));
-    }
-    resultAllEnd() {
-        const bxRest = new BXRest();
-        return this.resFirstPage().pipe(mergeMap(items => {
-            if (!items || !instanceOfiBXRestAnswerSuccess(items)) {
-                return from([]);
-            }
-            if (!items.total || items.total <= this.pageSize) {
-                return this.mapResult(items);
-            }
-            const pageCount = Math.ceil(items.total / this.pageSize);
-            const commands = Array.from({ length: pageCount - 1 }, (_, index) => {
-                const param = clone(this.param);
-                param.start = (index + 1) * this.pageSize;
-                return bxRest.batch({
-                    halt: 1,
-                    cmd: [this.http.getNameMethod(this.url) + '?' + serializeBitrixParams(param)]
-                }, this.requestHeaders);
-            });
-            return from(commands).pipe(concatMap(request => request), toArray(), mergeMap(results => {
-                const merged = { ...(items.result?.[this.key] ?? {}) };
-                for (const result of results) {
-                    if (result && instanceOfiBXRestAnswerSuccess(result)) {
-                        for (const page of result.result?.result ?? []) {
-                            Object.assign(merged, page?.[this.key] ?? {});
-                        }
-                    }
-                }
-                return this.mapResult({ result: { [this.key]: merged } });
-            }));
-        }), catchError(error => {
-            console.error(error);
-            return throwError(() => error);
-        }));
-    }
-    mapResult(items) {
-        if (!instanceOfiBXRestAnswerSuccess(items)) {
-            return from([]);
-        }
-        return from([items.result]).pipe(map$1(value => this.map?.(value)));
-    }
-}
-
-class NavvySupport {
-    constructor(requestClass) {
-        this.requestClass = requestClass;
-        this.pageSize = 50; // стандартный размер страницы
-    }
-    mapAndError(request) {
-        return request.pipe(map(v => BXRestMapResult(v)), catchError((err) => {
-            console.error(err);
-            throw new Error((err.error) ? err.error : err);
-        }));
-    }
-}
-
-class Navvy {
-    simple(url, arg, map) {
-        return new NavvySimple(url, arg !== undefined ? arg : undefined, map);
-    }
-    simpleV3(url, arg, map) {
-        return new NavvySimple(url, arg !== undefined ? arg : undefined, map, true);
-    }
-    /**
-     * Новый, пока тестируемый метод для api методов с пагинацией
-     *
-     * @param url
-     * @param arg
-     * @param map
-     * @constructor
-     */
-    pagNav(url, arg, map) {
-        return new NavvyPag(url, arg, map);
-    }
-    // old PagNav
-    // PagNav<T, R, A extends iBXRestPagination>(
-    //   func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
-    //   arg: A,
-    //   map: ((param: T[] | undefined) => R[] | undefined) | undefined) {
-    //   return new NavvyPagNav(this.requestClass, this.mapClass, func, arg, map)
-    // }
-    // Batch<T, R, A extends iBXRestPagination>(
-    //   func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
-    //   arg: A,
-    //   map: ((param: T[] | undefined) => R[] | undefined) | undefined) {
-    //   return new NavvyBatch(this.requestClass, this.mapClass, func, arg, map)
-    // }
-    pagNavTasks(url, 
-    // func: (param: A) => Observable<iBXRestAnswer<{tasks: T[] | undefined}> | undefined>,
-    arg, map) {
-        return new NavvyPagNavTasks(url, arg, map);
-    }
-    pagNavResultKey(url, arg, key, map) {
-        return new NavvyPagNavResultKey(url, arg, key, map);
-    }
-    pagNavResultKeyObject(url, arg, key, map) {
-        return new NavvyPagNavResultKeyObject(url, arg, key, map);
-    }
-    pagNavWithUselessKey(url, 
-    // func: (param: A) => Observable<iBXRestAnswer<{ [key: string]: T }> | undefined>,
-    arg, map) {
-        return new NavvyPagNavWithUselessKey(url, arg, map);
-    }
-    alterPagNav(url, 
-    // func: (param: A) => Observable<iBXRestAnswer<T[]> | undefined>,
-    arg, map) {
-        return new NavvyAlterPagNav(url, arg, map);
-    }
-}
+    $productImage: $productImage,
+    $productProperty: $productProperty,
+    $productPropertyEnum: $productPropertyEnum,
+    $productPropertyFeature: $productPropertyFeature,
+    $productPropertySection: $productPropertySection,
+    $productrow: $productrow,
+    $productrows: $productrows,
+    $property: $property,
+    $propertyGroup: $propertyGroup,
+    $propertyRelation: $propertyRelation,
+    $propertyValue: $propertyValue,
+    $propertyVariant: $propertyVariant,
+    $provider: $provider,
+    $public: $public,
+    $publication: $publication,
+    $publicationFolder: $publicationFolder,
+    $pull: $pull,
+    $quick: $quick,
+    $quote: $quote,
+    $ratio: $ratio,
+    $reaction: $reaction,
+    $read: $read,
+    $reading: $reading,
+    $recall: $recall,
+    $recent: $recent,
+    $recipient: $recipient,
+    $record: $record,
+    $recurring: $recurring,
+    $region: $region,
+    $register: $register,
+    $remove: $remove,
+    $removeAttachments: $removeAttachments,
+    $removeCard: $removeCard,
+    $removeEntities: $removeEntities,
+    $removecrmactivity: $removecrmactivity,
+    $rename: $rename,
+    $renew: $renew,
+    $reply: $reply,
+    $repo: $repo,
+    $report: $report,
+    $reports: $reports,
+    $repowidget: $repowidget,
+    $request: $request,
+    $requisite: $requisite,
+    $reset: $reset,
+    $resolveIdByPublicUrl: $resolveIdByPublicUrl,
+    $resource: $resource,
+    $resourcetype: $resourcetype,
+    $restore: $restore,
+    $restoreFromVersion: $restoreFromVersion,
+    $result: $result,
+    $resume: $resume,
+    $revision: $revision,
+    $rights: $rights,
+    $robot: $robot,
+    $role: $role,
+    $roundingRule: $roundingRule,
+    $sale: $sale,
+    $save: $save,
+    $schedule: $schedule,
+    $schema: $schema,
+    $search: $search,
+    $searchCrmEntities: $searchCrmEntities,
+    $section: $section,
+    $send: $send,
+    $sendContext: $sendContext,
+    $sendMessage: $sendMessage,
+    $sender: $sender,
+    $senders: $senders,
+    $server: $server,
+    $service: $service,
+    $session: $session,
+    $set: $set,
+    $setAccessCodes: $setAccessCodes,
+    $setDelivery: $setDelivery,
+    $setLandingRef: $setLandingRef,
+    $setOwner: $setOwner,
+    $setQuantity: $setQuantity,
+    $setRights: $setRights,
+    $setSiteRef: $setSiteRef,
+    $setowner: $setowner,
+    $settings: $settings,
+    $share: $share,
+    $sharetouser: $sharetouser,
+    $shipment: $shipment,
+    $shipmentItem: $shipmentItem,
+    $shipmentProperty: $shipmentProperty,
+    $shipmentPropertyValue: $shipmentPropertyValue,
+    $show: $show,
+    $showBlock: $showBlock,
+    $sign: $sign,
+    $silent: $silent,
+    $sip: $sip,
+    $site: $site,
+    $skip: $skip,
+    $sku: $sku,
+    $slots: $slots,
+    $socialnetwork: $socialnetwork,
+    $sonet_group: $sonet_group,
+    $source: $source,
+    $spam: $spam,
+    $stagehistory: $stagehistory,
+    $stages: $stages,
+    $start: $start,
+    $startwatch: $startwatch,
+    $startwithsound: $startwithsound,
+    $startwithtext: $startwithtext,
+    $statistic: $statistic,
+    $status: $status,
+    $statusLang: $statusLang,
+    $statuslist: $statuslist,
+    $stop: $stop,
+    $stopwatch: $stopwatch,
+    $storage: $storage,
+    $store: $store,
+    $storeProduct: $storeProduct,
+    $subscribe: $subscribe,
+    $syspage: $syspage,
+    $system: $system,
+    $tail: $tail,
+    $task: $task,
+    $tasks: $tasks,
+    $telephony: $telephony,
+    $template: $template,
+    $terminate: $terminate,
+    $text: $text,
+    $textField: $textField,
+    $thread: $thread,
+    $time: $time,
+    $timeMan: $timeMan,
+    $timecontrol: $timecontrol,
+    $timeline: $timeline,
+    $todo: $todo,
+    $trace: $trace,
+    $tracking: $tracking,
+    $tradeBinding: $tradeBinding,
+    $tradePlatform: $tradePlatform,
+    $transfer: $transfer,
+    $tree: $tree,
+    $trigger: $trigger,
+    $tts: $tts,
+    $type: $type,
+    $types: $types,
+    $unbind: $unbind,
+    $unbindingFromGroup: $unbindingFromGroup,
+    $unbindingFromMenu: $unbindingFromMenu,
+    $unfavoriteBlock: $unfavoriteBlock,
+    $unmute: $unmute,
+    $unpay: $unpay,
+    $unpin: $unpin,
+    $unpinAll: $unpinAll,
+    $unpublic: $unpublic,
+    $unpublicFolder: $unpublicFolder,
+    $unread: $unread,
+    $unregister: $unregister,
+    $unset: $unset,
+    $unsubscribe: $unsubscribe,
+    $upBlock: $upBlock,
+    $update: $update,
+    $updateAttrs: $updateAttrs,
+    $updateAvatar: $updateAvatar,
+    $updateCards: $updateCards,
+    $updateCatalogProduct: $updateCatalogProduct,
+    $updateColor: $updateColor,
+    $updateContent: $updateContent,
+    $updateDeadline: $updateDeadline,
+    $updateDescription: $updateDescription,
+    $updateFolder: $updateFolder,
+    $updateNodes: $updateNodes,
+    $updateResponsibleUser: $updateResponsibleUser,
+    $updateStyles: $updateStyles,
+    $updateTitle: $updateTitle,
+    $upload: $upload,
+    $uploadFile: $uploadFile,
+    $uploadfile: $uploadfile,
+    $uploadversion: $uploadversion,
+    $url: $url,
+    $user: $user,
+    $userconsent: $userconsent,
+    $userfield: $userfield,
+    $userfieldtype: $userfieldtype,
+    $users: $users,
+    $v1: $v1,
+    $v2: $v2,
+    $vat: $vat,
+    $version: $version,
+    $voices: $voices,
+    $volatileType: $volatileType,
+    $vote: $vote,
+    $voximplant: $voximplant,
+    $waitlist: $waitlist,
+    $workflow: $workflow,
+    $workgroup: $workgroup,
+    $writing: $writing
+});
 
 class BXRestNavvyUserUserfield {
     constructor() {
@@ -3801,8 +2704,9 @@ class BXRestMapUser {
         let res = Object.assign(clone(user), {
             ID: toNum(user.ID),
             IS_ONLINE: toBool(user.IS_ONLINE),
-            DATE_REGISTER: toDate(user.DATE_REGISTER),
-            PERSONAL_BIRTHDAY: toDate(user.PERSONAL_BIRTHDAY),
+            // Дня рождения может не быть вовсе (пустая строка), а при урезанном scope нет и самих полей
+            DATE_REGISTER: user.DATE_REGISTER ? toDate(user.DATE_REGISTER) : undefined,
+            PERSONAL_BIRTHDAY: user.PERSONAL_BIRTHDAY ? toDate(user.PERSONAL_BIRTHDAY) : undefined,
         });
         if (user.LAST_LOGIN) {
             res.LAST_LOGIN = toDate(user.LAST_LOGIN);
@@ -3813,7 +2717,7 @@ class BXRestMapUser {
         return Object.assign(clone(user), {
             ID: toStr(user.ID),
             IS_ONLINE: toBXYorN(user.IS_ONLINE),
-            DATE_REGISTER: toISOStringWithTimezone(user.DATE_REGISTER),
+            DATE_REGISTER: user.DATE_REGISTER ? toISOStringWithTimezone(user.DATE_REGISTER) : '',
             PERSONAL_BIRTHDAY: toStr(user.PERSONAL_BIRTHDAY),
             LAST_LOGIN: toStr(user.LAST_LOGIN)
         });
@@ -4306,8 +3210,8 @@ class BXRestMapTasksTaskResult {
 }
 
 class BXRestMapTasksTask {
-    constructor() {
-        this.result = BXRestMapTasksTaskResult;
+    static get result() {
+        return BXRestMapTasksTaskResult;
     }
     static getAccess(v) {
         return (v && v.allowedActions) ? v.allowedActions : undefined;
@@ -5272,6 +4176,10 @@ class BXRestNavvyOperationElapsedItem {
      * Возвращает список записей о затраченном времени по задаче.
      */
     getListByIDTask(ids) {
+        // Пустой batch завершается без значения, и вызывающий код получил бы EmptyError
+        if (!ids.length) {
+            return of([]);
+        }
         // Работает только потому что "nPageSize: 99999"
         return this.http.branch(ids.map(i => {
             return {
@@ -5374,33 +4282,17 @@ class BXRestNavvyOperationElapsedItem {
      * @param userCurrent
      */
     checkPermissionAddElapsedTimeToTask(idTask, userCurrent = undefined) {
-        // let permission = Permission.get()
-        // if (permission?.tasks?.length) {
-        //   let findTask = permission.tasks.find(i => i.id === idTask)
-        //   if (findTask?.permission) {
-        //     return of(findTask.permission['ELAPSEDTIME.ADD'])
-        //   }
         return ((userCurrent) ? of(userCurrent) : this.BXRestNavvyUser.current().res()).pipe(mergeMap(self => {
             if (self) {
                 return this.BXRestNavvyTasks.task.getAccess({
                     id: idTask,
                     users: [self.ID]
-                }).res().pipe(
-                // tap(v => {
-                //   if (v && v[self.ID]) {
-                //     Permission.set({
-                //       tasks: [{id: idTask, permission: v[self.ID], elapsedItem: []}]
-                //     })
-                //   }
-                // }),
-                map(v => {
+                }).res().pipe(map(v => {
                     return (v && v[self.ID]) ? v[self.ID]['ELAPSEDTIME.ADD'] : false;
                 }));
             }
             return of(undefined);
         }));
-        // }
-        // return of(undefined)
     }
     /**
      * Проверка на возможность прочтения такски
@@ -5409,35 +4301,17 @@ class BXRestNavvyOperationElapsedItem {
      * @param userCurrent
      */
     checkPermissionReadTask(idTask, userCurrent = undefined) {
-        // let permission = Permission.get()
-        // if (permission?.tasks?.length) {
-        //   let findTask = permission.tasks.find(i => i.id === idTask)
-        //   if (findTask?.permission) {
-        //     return of(findTask.permission.ACCEPT)
-        //   }
-        //   console.log('idTask', idTask)
         return ((userCurrent) ? of(userCurrent) : this.BXRestNavvyUser.current().res()).pipe(mergeMap(self => {
             if (self) {
                 return this.BXRestNavvyTasks.task.getAccess({
                     id: idTask,
                     users: [self.ID]
-                }).res().pipe(
-                // tap(v => {
-                //   if (v && v[self.ID]) {
-                //     Permission.set({
-                //       tasks: [{id: idTask, permission: v[self.ID], elapsedItem: []}]
-                //     })
-                //   }
-                // }),
-                map(v => {
+                }).res().pipe(map(v => {
                     return (v && v[self.ID]) ? !!v[self.ID] : false; // отдельного флага на чтение нет, выходит что если права отдались то и права есть
                 }));
             }
             return of(undefined);
         }));
-        // }
-        //
-        // return of(undefined)
     }
     /**
      * Законченный метод добавления записи с предварительной проверкой прав
@@ -5453,7 +4327,7 @@ class BXRestNavvyOperationElapsedItem {
                         return this.BXRestNavvyElapsedItem.add(param).res();
                     }
                     else {
-                        return throwError(() => new Error('Отсутствуют права добавление записи затраченного времени'));
+                        return throwError(() => new Error('Отсутствуют права на добавление записи затраченного времени'));
                     }
                 }));
             }
@@ -5481,42 +4355,15 @@ class BXRestNavvyOperationElapsedItem {
             return throwError(() => new Error('Отсутствуют права на чтение задачи'));
         }));
     }
-    // TODO: разобраться что это за ебатня в комментах и вписать нормальной комент если она нужна
     /**
      * Проверяет право на изменение записи о затраченном времени.
      */
     isAllowedModify(idTask, idItem) {
-        // let permission = Permission.get()
-        // if (permission?.tasks?.length) {
-        //   let findTask = permission.tasks.find(i => i.id === idTask)
-        //   if (findTask) {
-        //     let find = findTask.elapsedItem.find(i => i.id === idItem)
-        //     if (find && find.verified.edit) {
-        //       return of(find.edit)
-        //     }
-        //   }
-        // }
         return this.BXRestNavvyElapsedItem.isActionAllowed({
             TASKID: idTask,
             ITEMID: idItem,
             ACTIONID: 2
         }).res();
-        //   .pipe(
-        //   tap(v => {
-        //     if (v !== undefined) {
-        //       Permission.setTaskElapsedItem(idTask,
-        //         {
-        //           id: idItem,
-        //           edit: v,
-        //           del: false,
-        //           verified: {
-        //             edit: true,
-        //             del: false,
-        //           }
-        //         })
-        //     }
-        //   })
-        // )
     }
     /**
      * isActionAllowed с фиксом на проверку возможности чтения задачи записи
@@ -7017,7 +5864,7 @@ class BXRestNavvyBizProc {
         // Не понимаю почему DATE_CREATE указывается не на сервере
         // но если пользователь не указал, надо указать
         const value = parametersElement['DATE_CREATE'];
-        if (value === null || value === undefined || (typeof value === 'string' || value.trim() === '')) {
+        if (value === null || value === undefined || (typeof value === 'string' && value.trim() === '')) {
             parametersElement['DATE_CREATE'] = new Date();
         }
         return this.BXRestNavvyLists.element.add({
@@ -8414,40 +7261,6 @@ class BXRestNavvyImNotify {
     }
 }
 
-function CatchError(options) {
-    return function (target, propertyKey, descriptor) {
-        const original = descriptor.value;
-        descriptor.value = function (...args) {
-            try {
-                return original.apply(this, args);
-            }
-            catch (err) {
-                const errorInfo = {
-                    message: `❌ Error in ${target.constructor.name}.${propertyKey}`,
-                    args,
-                    error: err instanceof Error ? err.message : String(err),
-                    stack: err instanceof Error ? err.stack : new Error().stack,
-                };
-                console.error(formatError(errorInfo));
-                if (options?.rethrow)
-                    throw err;
-                return options?.defaultValue;
-            }
-        };
-        return descriptor;
-    };
-}
-// Общая функция форматирования
-function formatError(info) {
-    const stackLines = info.stack?.split('\n').slice(2).join('\n');
-    return [
-        info.message,
-        info.args ? `   • args: ${JSON.stringify(info.args)}` : '',
-        info.error ? `   • error: ${info.error}` : '',
-        `   • stack trace:\n${stackLines}`,
-    ].join('\n');
-}
-
 class BXRestMapImRecent {
     static get(value) {
         return value
@@ -8518,12 +7331,6 @@ class BXRestMapImRecent {
         return chat;
     }
 }
-__decorate([
-    CatchError({ rethrow: true })
-], BXRestMapImRecent, "get", null);
-__decorate([
-    CatchError({ rethrow: true })
-], BXRestMapImRecent, "list", null);
 
 class BXRestNavvyImRecent {
     constructor() {
@@ -9362,17 +8169,6 @@ class BXRestMapPull {
     }
 }
 
-class BXRestMapPullChannelPublic {
-    static get(value) {
-        return value ? {
-            ...value,
-            start: toDate(value.start),
-            end: toDate(value.end)
-        }
-            : undefined;
-    }
-}
-
 class BXRestNavvyPullConfig {
     constructor() {
         this.url = {
@@ -9383,7 +8179,6 @@ class BXRestNavvyPullConfig {
         };
         this.Navvy = new Navvy();
     }
-    static { this.public = new BXRestMapPullChannelPublic(); }
     /**
      * @experimental
      * Этот метод находится в процессе тестирования и может измениться.
@@ -9393,6 +8188,17 @@ class BXRestNavvyPullConfig {
     }
 }
 
+class BXRestMapPullChannelPublic {
+    static get(value) {
+        return value ? {
+            ...value,
+            start: toDate(value.start),
+            end: toDate(value.end)
+        }
+            : undefined;
+    }
+}
+
 class BXRestNavvyPullChannelPublic {
     constructor() {
         this.url = {
@@ -20291,6 +19097,15 @@ class BXRestNavvy {
     }
 }
 
+class BXRestMapDisk {
+    constructor() {
+        this.folder = new BXRestMapDiskFolder();
+        this.attachedObject = new BXRestMapDiskAttachedObject();
+        this.file = new BXRestMapDiskFile();
+        this.storage = new BXRestMapDiskStorage();
+    }
+}
+
 class BXRestMapCalendarUser {
     constructor() {
         this.settings = new BXRestMapCalendarUserSettings();
@@ -20322,16 +19137,23 @@ class BXRestMapTaskStage {
 }
 
 class BXRestMapTask {
-    constructor() {
-        this.commentItem = new BXRestMapTaskCommentItem();
-        this.elapsedItem = new BXRestMapTaskElapsedItem();
-        this.stages = new BXRestMapTaskStage();
+    // Геттеры, а не статические поля: статический инициализатор выполняется при загрузке
+    // модуля, поэтому бандлер не сможет выбросить класс, даже если он нигде не используется.
+    static get commentItem() {
+        return BXRestMapTaskCommentItem;
+    }
+    static get elapsedItem() {
+        return BXRestMapTaskElapsedItem;
+    }
+    static get stages() {
+        return BXRestMapTaskStage;
     }
 }
 
 class BXRestMapTasks {
-    constructor() {
-        this.task = new BXRestMapTasksTask();
+    // Геттер — по той же причине, что и в BXRestMapTask
+    static get task() {
+        return BXRestMapTasksTask;
     }
 }
 
@@ -20349,7 +19171,7 @@ class BXRestMap {
         return BXRestMapLists;
     }
     get disk() {
-        return BXRestDisk;
+        return BXRestMapDisk;
     }
     get calendar() {
         return BXRestMapCalendar;
@@ -20935,6 +19757,19 @@ function toRecord(value) {
         : {};
 }
 
+class HttpNavvyServices {
+    constructor() {
+        this.httpServices = new HttpBXServices();
+    }
+    // Реализация метода
+    post(url, params) {
+        if (params === undefined) {
+            params = {};
+        }
+        return this.httpServices.post(url, params);
+    }
+}
+
 /**
  * Public API Surface of bx-rest
  */