bx-rest 0.26.0 → 1.0.0

package/esm2022/request-navvy/sonet_group/user.mjs

@@ -0,0 +1,59 @@
+import { $add, $delete, $get, $groups, $invite, $request, $sonet_group, $update, $user } from '../../consts/part-name-methods';
+import { Navvy } from '../../services/navvy';
+export class BXRestNavvySonetGroupUser {
+    constructor() {
+        this.Navvy = new Navvy();
+        this.url = {
+            add: [$sonet_group, $user, $add],
+            delete: [$sonet_group, $user, $delete],
+            get: [$sonet_group, $user, $get],
+            groups: [$sonet_group, $user, $groups],
+            invite: [$sonet_group, $user, $invite],
+            request: [$sonet_group, $user, $request],
+            update: [$sonet_group, $user, $update]
+        };
+    }
+    /**
+     * Добавляет пользователей в рабочую группу.
+     */
+    add(param) {
+        return this.Navvy.simple(this.url.add, param);
+    }
+    /**
+     * Удаляет пользователей из рабочей группы.
+     */
+    delete(param) {
+        return this.Navvy.simple(this.url.delete, param);
+    }
+    /**
+     * Возвращает список участников рабочей группы.
+     */
+    get(param) {
+        return this.Navvy.simple(this.url.get, param);
+    }
+    /**
+     * Возвращает список групп текущего пользователя.
+     */
+    groups() {
+        return this.Navvy.simple(this.url.groups);
+    }
+    /**
+     * Приглашает пользователей в рабочую группу.
+     */
+    invite(param) {
+        return this.Navvy.simple(this.url.invite, param);
+    }
+    /**
+     * Отправляет запрос на вступление в рабочую группу.
+     */
+    request(param) {
+        return this.Navvy.simple(this.url.request, param);
+    }
+    /**
+     * Изменяет роль пользователя в рабочей группе.
+     */
+    update(param) {
+        return this.Navvy.simple(this.url.update, param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/sonet_group.mjs

@@ -0,0 +1,56 @@
+import { $create, $delete, $get, $setowner, $sonet_group, $update } from '../consts/part-name-methods';
+import { BXRestMapSonetGroup } from '../map/sonet_group';
+import { BXRestNavvySonetGroupFeature } from './sonet_group/feature';
+import { BXRestNavvySonetGroupUser } from './sonet_group/user';
+import { Navvy } from '../services/navvy';
+export class BXRestNavvySonetGroup {
+    constructor() {
+        this.Navvy = new Navvy();
+        this.url = {
+            create: [$sonet_group, $create],
+            delete: [$sonet_group, $delete],
+            get: [$sonet_group, $get],
+            setOwner: [$sonet_group, $setowner],
+            update: [$sonet_group, $update]
+        };
+        /**
+         * Проверка прав на функциональность рабочей группы (`sonet_group.feature.*`).
+         */
+        this.feature = new BXRestNavvySonetGroupFeature();
+        /**
+         * Участники рабочей группы (`sonet_group.user.*`).
+         */
+        this.user = new BXRestNavvySonetGroupUser();
+    }
+    /**
+     * Создаёт рабочую группу или проект.
+     */
+    create(param) {
+        return this.Navvy.simple(this.url.create, param);
+    }
+    /**
+     * Удаляет рабочую группу.
+     */
+    delete(param) {
+        return this.Navvy.simple(this.url.delete, param);
+    }
+    /**
+     * Возвращает список рабочих групп.
+     */
+    get(param = {}) {
+        return this.Navvy.simple(this.url.get, param, BXRestMapSonetGroup.get);
+    }
+    /**
+     * Изменяет владельца рабочей группы.
+     */
+    setOwner(param) {
+        return this.Navvy.simple(this.url.setOwner, param);
+    }
+    /**
+     * Изменяет параметры рабочей группы.
+     */
+    update(param) {
+        return this.Navvy.simple(this.url.update, param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/task/checklistitem.mjs

@@ -0,0 +1,68 @@
+import { Navvy } from '../../services/navvy';
+import { $add, $checklistitem, $complete, $delete, $get, $getlist, $getmanifest, $isactionallowed, $moveafteritem, $renew, $task, $update } from '../../consts/part-name-methods';
+export class BXRestNavvyTaskChecklistItem {
+    constructor() {
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Добавляет элемент чек-листа к задаче.
+     */
+    add(param) {
+        return this.Navvy.simple([$task, $checklistitem, $add], param);
+    }
+    /**
+     * Отмечает элемент чек-листа как выполненный.
+     */
+    complete(param) {
+        return this.Navvy.simple([$task, $checklistitem, $complete], param);
+    }
+    /**
+     * Удаляет элемент чек-листа.
+     */
+    delete(param) {
+        return this.Navvy.simple([$task, $checklistitem, $delete], param);
+    }
+    /**
+     * Возвращает элемент чек-листа по идентификатору.
+     */
+    get(param) {
+        return this.Navvy.simple([$task, $checklistitem, $get], param);
+    }
+    /**
+     * Возвращает список элементов чек-листа.
+     */
+    getlist(param) {
+        return this.Navvy.simple([$task, $checklistitem, $getlist], param);
+    }
+    /**
+     * Возвращает список методов чек-листа и их описание.
+     */
+    getmanifest() {
+        return this.Navvy.simple([$task, $checklistitem, $getmanifest]);
+    }
+    /**
+     * Проверяет, разрешено ли действие с элементом чек-листа.
+     */
+    isactionallowed(param) {
+        return this.Navvy.simple([$task, $checklistitem, $isactionallowed], param);
+    }
+    /**
+     * Помещает элемент чек-листа после указанного.
+     */
+    moveafteritem(param) {
+        return this.Navvy.simple([$task, $checklistitem, $moveafteritem], param);
+    }
+    /**
+     * Отмечает выполненный элемент чек-листа как активный.
+     */
+    renew(param) {
+        return this.Navvy.simple([$task, $checklistitem, $renew], param);
+    }
+    /**
+     * Обновляет данные элемента чек-листа.
+     */
+    update(param) {
+        return this.Navvy.simple([$task, $checklistitem, $update], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/task/commentitem.mjs

@@ -0,0 +1,74 @@
+import { Navvy } from '../../services/navvy';
+import { BXRestMapTaskCommentItem } from '../../map/task/commentitem';
+import { mergeMap, of } from 'rxjs';
+import { $add, $commentitem, $delete, $get, $getlist, $getmanifest, $isactionallowed, $task, $update } from '../../consts/part-name-methods';
+export class BXRestNavvyTaskCommentItem {
+    constructor() {
+        this.url = {
+            getList: [$task, $commentitem, $getlist],
+            get: [$task, $commentitem, $get],
+            add: [$task, $commentitem, $add],
+            update: [$task, $commentitem, $update],
+            delete: [$task, $commentitem, $delete],
+        };
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Создаёт новый комментарий к задаче.
+     */
+    add(param) {
+        return this.Navvy.simple(this.url.add, param);
+    }
+    /**
+     * Обновляет данные комментария.
+     */
+    update(param) {
+        return this.Navvy.simple(this.url.update, param);
+    }
+    /**
+     * Возвращает комментарий к задаче.
+     */
+    get(param) {
+        return this.Navvy.simple(this.url.get, param, BXRestMapTaskCommentItem.get);
+    }
+    /**
+     * Возвращает список комментариев к задаче.
+     */
+    getlist(param = {
+        FILTER: {},
+        ORDER: {
+            POST_DATE: 'asc'
+        }
+    }) {
+        return this.Navvy.simple(this.url.getList, param, BXRestMapTaskCommentItem.getlist);
+    }
+    /**
+     * Удаляет комментарий.
+     */
+    del(param) {
+        if (param.ITEMID > 0) {
+            return this.get(param).res().pipe(mergeMap(v => {
+                if (v) {
+                    return this.Navvy.simple(this.url.delete, param).res();
+                }
+                return of(false);
+            }));
+        }
+        else {
+            return of(false);
+        }
+    }
+    /**
+     * Возвращает список методов комментариев и их описание.
+     */
+    getmanifest() {
+        return this.Navvy.simple([$task, $commentitem, $getmanifest]);
+    }
+    /**
+     * Проверяет, разрешено ли действие с комментарием.
+     */
+    isactionallowed(param) {
+        return this.Navvy.simple([$task, $commentitem, $isactionallowed], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/task/delegate/elapseditem.mjs

@@ -0,0 +1,28 @@
+import { Navvy } from '../../../services/navvy';
+import { BXRestMapTaskElapsedItem } from '../../../map/task/elapseditem';
+import { $elapseditem, $getlist, $task } from '../../../consts/part-name-methods';
+export class BXRestNavvyDelegateElapsedItem {
+    constructor() {
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Возвращает список записей о затраченном времени по задаче.
+     */
+    getList(param = {}) {
+        if (param) {
+            if (!param.TASKID && !param.SELECT) {
+                param.SELECT = ['*'];
+            }
+            if (!param.TASKID && !param.PARAMS) {
+                param.PARAMS = {
+                    NAV_PARAMS: {
+                        nPageSize: 50,
+                        iNumPage: 1
+                    }
+                };
+            }
+        }
+        return this.Navvy.alterPagNav([$task, $elapseditem, $getlist], param, BXRestMapTaskElapsedItem.getList);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/task/dependence.mjs

@@ -0,0 +1,20 @@
+import { Navvy } from '../../services/navvy';
+import { $add, $delete, $dependence, $task } from '../../consts/part-name-methods';
+export class BXRestNavvyTaskDependence {
+    constructor() {
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Создаёт зависимость одной задачи от другой.
+     */
+    add(param) {
+        return this.Navvy.simple([$task, $dependence, $add], param);
+    }
+    /**
+     * Удаляет зависимость одной задачи от другой.
+     */
+    delete(param) {
+        return this.Navvy.simple([$task, $dependence, $delete], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/task/elapseditem.mjs

@@ -0,0 +1,93 @@
+import { Navvy } from '../../services/navvy';
+import { BXRestNavvyOperationElapsedItem } from './operation/elapseditem';
+import { BXRestNavvyDelegateElapsedItem } from './delegate/elapseditem';
+import { $add, $delete, $elapseditem, $get, $getlist, $getmanifest, $isActionAllowed, $task, $update } from '../../consts/part-name-methods';
+export class BXRestNavvyElapsedItem {
+    constructor() {
+        this.url = {
+            // /**
+            //  * Возвращает список методов и их описание
+            //  */
+            // getManifest: [$task, $elapseditem, $getmanifest],
+            /**
+             * Возвращает список записей о затраченном времени по задаче
+             */
+            getList: [$task, $elapseditem, $getlist],
+            // /**
+            //  * Возвращает запись о затраченном времени по ее идентификатору
+            //  */
+            // get: [$task, $elapseditem, $get],
+            /**
+             * Добавляет затраченное время к задаче
+             */
+            add: [$task, $elapseditem, $add],
+            /**
+             * Удаляет запись о затраченном времени
+             */
+            delete: [$task, $elapseditem, $delete],
+            /**
+             * Проверяет разрешено ли действие
+             */
+            isActionAllowed: [$task, $elapseditem, $isActionAllowed],
+            /**
+             * Изменяет параметры записи о затраченном времени
+             */
+            update: [$task, $elapseditem, $update],
+        };
+        this.delegate = new BXRestNavvyDelegateElapsedItem();
+        /**
+         * Затраченное время по задаче (`task.elapseditem.*`).
+         */
+        this.operation = new BXRestNavvyOperationElapsedItem(this);
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Возвращает список записей о затраченном времени через делегирующий сервис.
+     */
+    getList(param = {}) {
+        return this.delegate.getList(param);
+    }
+    /**
+     * Добавляет затраченное время к задаче.
+     */
+    add(param) {
+        return this.Navvy.simple(this.url.add, param);
+    }
+    /**
+     * Обновление записи рабочего времени
+     *
+     * @param param
+     */
+    update(param) {
+        return this.Navvy.simple(this.url.update, param);
+    }
+    /**
+     * idAction:
+     * 1 - ACTION_ELAPSED_TIME_ADD
+     * 2 - ACTION_ELAPSED_TIME_MODIFY
+     * 3 - ACTION_ELAPSED_TIME_REMOVE
+     * @param param
+     */
+    isActionAllowed(param) {
+        return this.Navvy.simple(this.url.isActionAllowed, param);
+    }
+    /**
+     * Удаляет запись о затраченном времени.
+     */
+    delete(param) {
+        return this.Navvy.simple(this.url.delete, param);
+    }
+    /**
+     * Возвращает запись о затраченном времени.
+     */
+    get(param) {
+        return this.Navvy.simple([$task, $elapseditem, $get], param);
+    }
+    /**
+     * Возвращает список методов затраченного времени и их описание.
+     */
+    getManifest() {
+        return this.Navvy.simple([$task, $elapseditem, $getmanifest]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elapseditem.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/request-navvy/task/elapseditem.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAC5C,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAA;AACzE,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAA;AACvE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,gBAAgB,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAA;AAE5I,MAAM,OAAO,sBAAsB;IAAnC;QACY,QAAG,GAAG;YACd,MAAM;YACN,6CAA6C;YAC7C,MAAM;YACN,oDAAoD;YACpD;;eAEG;YACH,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC;YACxC,MAAM;YACN,kEAAkE;YAClE,MAAM;YACN,oCAAoC;YACpC;;eAEG;YACH,GAAG,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,CAAC;YAChC;;eAEG;YACH,MAAM,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC;YACtC;;eAEG;YACH,eAAe,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,gBAAgB,CAAC;YACxD;;eAEG;YACH,MAAM,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC;SACvC,CAAA;QACgB,aAAQ,GAAG,IAAI,8BAA8B,EAAE,CAAA;QAChE;;WAEG;QACa,cAAS,GAAG,IAAI,+BAA+B,CAAC,IAAI,CAAC,CAAA;QAEpD,UAAK,GAAG,IAAI,KAAK,EAAE,CAAA;IA+DtC,CAAC;IA7DC;;OAEG;IACH,OAAO,CACL,QAAoC,EAAE;QAEtC,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACrC,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,KAAiC;QACnC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAA6C,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAC3F,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAoC;QACzC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAA4C,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC7F,CAAC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,KAA4B;QAC1C,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAA0C,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,KAAK,CAAC,CAAA;IACpG,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAiC;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAyC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC1F,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,KAAiC;QACnC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAItB,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAA;IACvC,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAoB,CAAC,KAAK,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAA;IAClF,CAAC;CAEF","sourcesContent":["import {\r\n  iBXRestParamElapseditemGet,\r\n  iBXRestParamAddElapseditem,\r\n  iBXRestParamUpdateElapseditem,\r\n  iBXRestParamDelElapseditem,\r\n  iIsActionAllowedParam,\n  iBXRestTaskObject,\n  iBXRestTaskElapsedItem\n} from '../../typification/rest/task'\r\nimport { Navvy } from '../../services/navvy'\r\nimport { BXRestNavvyOperationElapsedItem } from './operation/elapseditem'\r\nimport { BXRestNavvyDelegateElapsedItem } from './delegate/elapseditem'\r\nimport { $add, $delete, $elapseditem, $get, $getlist, $getmanifest, $isActionAllowed, $task, $update } from '../../consts/part-name-methods'\n\r\nexport class BXRestNavvyElapsedItem {\r\n  protected url = {\r\n    // /**\r\n    //  * Возвращает список методов и их описание\r\n    //  */\r\n    // getManifest: [$task, $elapseditem, $getmanifest],\r\n    /**\r\n     * Возвращает список записей о затраченном времени по задаче\r\n     */\r\n    getList: [$task, $elapseditem, $getlist],\r\n    // /**\r\n    //  * Возвращает запись о затраченном времени по ее идентификатору\r\n    //  */\r\n    // get: [$task, $elapseditem, $get],\r\n    /**\r\n     * Добавляет затраченное время к задаче\r\n     */\r\n    add: [$task, $elapseditem, $add],\r\n    /**\r\n     * Удаляет запись о затраченном времени\r\n     */\r\n    delete: [$task, $elapseditem, $delete],\r\n    /**\r\n     * Проверяет разрешено ли действие\r\n     */\r\n    isActionAllowed: [$task, $elapseditem, $isActionAllowed],\n    /**\r\n     * Изменяет параметры записи о затраченном времени\r\n     */\r\n    update: [$task, $elapseditem, $update],\r\n  }\r\n  private readonly delegate = new BXRestNavvyDelegateElapsedItem()\r\n  /**\n   * Затраченное время по задаче (`task.elapseditem.*`).\n   */\n  public readonly operation = new BXRestNavvyOperationElapsedItem(this)\r\n\r\n  private readonly Navvy = new Navvy()\r\n\r\n  /**\n   * Возвращает список записей о затраченном времени через делегирующий сервис.\n   */\n  getList(\n    param: iBXRestParamElapseditemGet = {}\r\n  ) {\r\n    return this.delegate.getList(param)\r\n  }\r\n\r\n  /**\n   * Добавляет затраченное время к задаче.\n   */\n  add(param: iBXRestParamAddElapseditem) {\r\n    return this.Navvy.simple<number, number, iBXRestParamAddElapseditem>(this.url.add, param)\r\n  }\r\n\r\n  /**\r\n   * Обновление записи рабочего времени\r\n   *\r\n   * @param param\r\n   */\r\n  update(param: iBXRestParamUpdateElapseditem) {\r\n    return this.Navvy.simple<null, null, iBXRestParamUpdateElapseditem>(this.url.update, param)\r\n  }\r\n\r\n  /**\r\n   * idAction:\r\n   * 1 - ACTION_ELAPSED_TIME_ADD\r\n   * 2 - ACTION_ELAPSED_TIME_MODIFY\r\n   * 3 - ACTION_ELAPSED_TIME_REMOVE\r\n   * @param param\r\n   */\r\n  isActionAllowed(param: iIsActionAllowedParam) {\r\n    return this.Navvy.simple<boolean, boolean, iIsActionAllowedParam>(this.url.isActionAllowed, param)\r\n  }\r\n\r\n  /**\n   * Удаляет запись о затраченном времени.\n   */\n  delete(param: iBXRestParamDelElapseditem) {\n    return this.Navvy.simple<null, null, iBXRestParamDelElapseditem>(this.url.delete, param)\r\n  }\n\n  /**\n   * Возвращает запись о затраченном времени.\n   */\n  get(param: iBXRestParamDelElapseditem) {\n    return this.Navvy.simple<\n      iBXRestTaskElapsedItem,\n      iBXRestTaskElapsedItem,\n      iBXRestParamDelElapseditem\n    >([$task, $elapseditem, $get], param)\n  }\n\n  /**\n   * Возвращает список методов затраченного времени и их описание.\n   */\n  getManifest() {\n    return this.Navvy.simple<iBXRestTaskObject>([$task, $elapseditem, $getmanifest])\n  }\n\n}\n"]}

package/esm2022/request-navvy/task/item/userfield.mjs

@@ -0,0 +1,81 @@
+import { Navvy } from '../../../services/navvy';
+import { BXRestMapTaskUserField } from '../../../map/task/item/userfield';
+import { $add, $delete, $get, $getFields, $getlist, $gettypes, $item, $task, $update, $userfield } from '../../../consts/part-name-methods';
+export class BXRestNavvyTaskItemUserField {
+    constructor() {
+        this.url = {
+            /**
+             * Получение всех доступных полей свойства
+             */
+            getFields: [$task, $item, $userfield, $getFields],
+            // /**
+            //  * Получение всех доступных типов данных
+            //  */
+            // getTypes: [$task, $item, $userfield, 'gettypes'],
+            // /**
+            //  * Создание нового свойства
+            //  */
+            // add: [$task, $item, $userfield, $add],
+            // /**
+            //  * Получение свойства по идентификатору
+            //  */
+            // get: [$task, $item, $userfield, $get],
+            /**
+             * Получение списка свойств
+             */
+            getList: [$task, $item, $userfield, $getlist],
+            // /**
+            //  * Редактирование параметров свойства
+            //  */
+            // update: [$task, $item, $userfield, $update],
+            // /**
+            //  * Удаление свойства
+            //  */
+            // delete: [$task, $item, $userfield, $delete]
+        };
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Возвращает список пользовательских полей задачи.
+     */
+    getList(param = {}) {
+        return this.Navvy.pagNav(this.url.getList, param, BXRestMapTaskUserField.getList);
+    }
+    /**
+     * Создаёт новое пользовательское поле задачи.
+     */
+    add(param) {
+        return this.Navvy.simple([$task, $item, $userfield, $add], param);
+    }
+    /**
+     * Удаляет пользовательское поле задачи.
+     */
+    delete(param) {
+        return this.Navvy.simple([$task, $item, $userfield, $delete], param);
+    }
+    /**
+     * Возвращает пользовательское поле задачи по идентификатору.
+     */
+    get(param) {
+        return this.Navvy.simple([$task, $item, $userfield, $get], param);
+    }
+    /**
+     * Возвращает доступные поля пользовательского поля задачи.
+     */
+    getFields() {
+        return this.Navvy.simple([$task, $item, $userfield, $getFields]);
+    }
+    /**
+     * Возвращает все доступные типы данных пользовательских полей.
+     */
+    getTypes() {
+        return this.Navvy.simple([$task, $item, $userfield, $gettypes]);
+    }
+    /**
+     * Обновляет параметры пользовательского поля задачи.
+     */
+    update(param) {
+        return this.Navvy.simple([$task, $item, $userfield, $update], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/task/item.mjs

@@ -0,0 +1,10 @@
+import { BXRestNavvyTaskItemUserField } from './item/userfield';
+export class BXRestNavvyTaskItem {
+    constructor() {
+        /**
+         * Пользовательские поля задачи (`task.item.userfield.*`).
+         */
+        this.userField = new BXRestNavvyTaskItemUserField();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J4LXJlc3Qvc3JjL3JlcXVlc3QtbmF2dnkvdGFzay9pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLGtCQUFrQixDQUFBO0FBRS9ELE1BQU0sT0FBTyxtQkFBbUI7SUFBaEM7UUFDRTs7V0FFRztRQUNhLGNBQVMsR0FBRyxJQUFJLDRCQUE0QixFQUFFLENBQUE7SUFDaEUsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQlhSZXN0TmF2dnlUYXNrSXRlbVVzZXJGaWVsZCB9IGZyb20gJy4vaXRlbS91c2VyZmllbGQnXHJcblxyXG5leHBvcnQgY2xhc3MgQlhSZXN0TmF2dnlUYXNrSXRlbSB7XHJcbiAgLyoqXG4gICAqINCf0L7Qu9GM0LfQvtCy0LDRgtC10LvRjNGB0LrQuNC1INC/0L7Qu9GPINC30LDQtNCw0YfQuCAoYHRhc2suaXRlbS51c2VyZmllbGQuKmApLlxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IHVzZXJGaWVsZCA9IG5ldyBCWFJlc3ROYXZ2eVRhc2tJdGVtVXNlckZpZWxkKClcclxufSJdfQ==