bx-rest 0.1.0 → 0.1.5

package/map/lists.d.ts

@@ -1,7 +1,7 @@
 import BaseMapServices from './base';
 import BXRestListsElementMap from './lists/element';
 import * as i0 from "@angular/core";
-export default class BXRestMapLists extends BaseMapServices {
+export declare class BXRestMapLists extends BaseMapServices {
     element: BXRestListsElementMap;
     constructor(element: BXRestListsElementMap);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapLists, never>;

package/map/task.d.ts

@@ -2,7 +2,10 @@ import BaseMapServices from './base';
 import { iBXRestHttpTask, iBXRestTask } from '../typification/rest/task/task';
 import * as i0 from "@angular/core";
 export declare class BXRestTaskMap extends BaseMapServices {
-    TaskBXHttpToTaskBX(item: iBXRestHttpTask): iBXRestTask;
+    add(item: iBXRestHttpTask): iBXRestTask;
+    get(item: iBXRestHttpTask): iBXRestTask;
+    list(item: iBXRestHttpTask[]): iBXRestTask[];
+    private TaskBXHttpToTaskBX;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestTaskMap, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestTaskMap>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bx-rest",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "description": "bitrix rest api",
   "keywords": [
     "bitrxi",

package/public-api.d.ts

@@ -1,3 +1,3 @@
-export { REST_SETTINGS } from './settings';
+export { BX_REST_SETTINGS } from './settings';
 export { BXRestMapResult } from './functions/mapResult';
 export { BXRest, BXRestNavvy, BXRestMap } from './rest';

package/request/bizproc/activity.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocActivity {
+    url: {
+        add: string[];
+        delete: string[];
+        list: string[];
+        update: string[];
+        log: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocActivity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocActivity>;
+}

package/request/bizproc/event.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocEvent {
+    url: {
+        send: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocEvent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocEvent>;
+}

package/request/bizproc/robot.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocRobot {
+    url: {
+        add: string[];
+        delete: string[];
+        list: string[];
+        update: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocRobot, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocRobot>;
+}

package/request/bizproc/task.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocTask {
+    url: {
+        complete: string[];
+        list: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocTask, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocTask>;
+}

package/request/bizproc/workflow/instance.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocWorkflowInstance {
+    url: {
+        list: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocWorkflowInstance, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocWorkflowInstance>;
+}

package/request/bizproc/workflow/template.d.ts

@@ -0,0 +1,16 @@
+import { iBXRestParamBizprocWorkflowTemplateList } from '../../../typification/rest/bizproc/workflow/template/list';
+import HttpBXServices from '../../../services/http/HttpBX';
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocWorkflowTemplate {
+    private http;
+    url: {
+        add: string[];
+        delete: string[];
+        update: string[];
+        list: string[];
+    };
+    constructor(http: HttpBXServices);
+    list(param?: iBXRestParamBizprocWorkflowTemplateList): import("rxjs").Observable<import("../../../typification/rest/base/answer").iBXRestAnswer<unknown> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocWorkflowTemplate, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocWorkflowTemplate>;
+}

package/request/bizproc/workflow.d.ts

@@ -0,0 +1,20 @@
+import { BXRestBizprocWorkflowInstance } from './workflow/instance';
+import { BXRestBizprocWorkflowTemplate } from './workflow/template';
+import HttpBXServices from '../../services/http/HttpBX';
+import { iBXRestParamBizprocWorkflowStart } from '../../typification/rest/bizproc/workflow/start';
+import * as i0 from "@angular/core";
+export declare class BXRestBizprocWorkflow {
+    instances: BXRestBizprocWorkflowInstance;
+    template: BXRestBizprocWorkflowTemplate;
+    private http;
+    url: {
+        instances: string[];
+        terminate: string[];
+        start: string[];
+        kill: string[];
+    };
+    constructor(instances: BXRestBizprocWorkflowInstance, template: BXRestBizprocWorkflowTemplate, http: HttpBXServices);
+    start(param: iBXRestParamBizprocWorkflowStart): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<string> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizprocWorkflow, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizprocWorkflow>;
+}

package/request/bizproc.d.ts

@@ -0,0 +1,16 @@
+import { BXRestBizprocWorkflow } from './bizproc/workflow';
+import { BXRestBizprocActivity } from './bizproc/activity';
+import { BXRestBizprocTask } from './bizproc/task';
+import { BXRestBizprocRobot } from './bizproc/robot';
+import { BXRestBizprocEvent } from './bizproc/event';
+import * as i0 from "@angular/core";
+export declare class BXRestBizproc {
+    workflow: BXRestBizprocWorkflow;
+    activity: BXRestBizprocActivity;
+    task: BXRestBizprocTask;
+    robot: BXRestBizprocRobot;
+    event: BXRestBizprocEvent;
+    constructor(workflow: BXRestBizprocWorkflow, activity: BXRestBizprocActivity, task: BXRestBizprocTask, robot: BXRestBizprocRobot, event: BXRestBizprocEvent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestBizproc, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestBizproc>;
+}

package/request/lists/element.d.ts

@@ -1,5 +1,6 @@
 import HttpBXServices from '../../services/http/HttpBX';
 import { iBXRestHttpListsElement, iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
+import { iBXRestParamListsElementAdd } from '../../typification/rest/lists/element/add';
 import * as i0 from "@angular/core";
 export declare class BXRestListsElement {
     private http;
@@ -12,7 +13,7 @@ export declare class BXRestListsElement {
     };
     constructor(http: HttpBXServices);
     get(pram: iBXRestParamListsElementGet): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestHttpListsElement[]> | undefined>;
-    customPipe(): void;
+    add(param: iBXRestParamListsElementAdd): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<number> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestListsElement, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestListsElement>;
 }

package/request/lists.d.ts

@@ -1,6 +1,6 @@
 import { BXRestListsElement } from './lists/element';
 import * as i0 from "@angular/core";
-export default class BXRestLists {
+export declare class BXRestLists {
     element: BXRestListsElement;
     url: {
         add: string[];

package/request/tasks/task.d.ts

@@ -1,6 +1,8 @@
 import HttpBXServices from '../../services/http/HttpBX';
-import { iBXRestParamTaskAdd } from '../../typification/rest/task/fieldsForSend';
 import { iBXRestHttpTask } from '../../typification/rest/task/task';
+import { iBXRestParamTaskAdd } from '../../typification/rest/tasks/task/add';
+import iBXRestParamTaskGet from '../../typification/rest/tasks/task/get';
+import { iBXRestParamTasksList } from '../../typification/rest/tasks/task/list';
 import * as i0 from "@angular/core";
 export declare class BXRestTasksTask {
     private http;
@@ -50,6 +52,12 @@ export declare class BXRestTasksTask {
     }): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<{
         task: iBXRestHttpTask;
     }> | undefined>;
+    get(requestArray: iBXRestParamTaskGet): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<{
+        task: iBXRestHttpTask | undefined;
+    }> | undefined>;
+    list(param?: iBXRestParamTasksList): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<{
+        tasks: iBXRestHttpTask[] | undefined;
+    }> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestTasksTask, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestTasksTask>;
 }

package/request/user.d.ts

@@ -1,13 +1,13 @@
-import { iBXGetParam } from '../typification/rest/user/get';
+import { iBXRestParamUserGet } from '../typification/rest/user/get';
 import HttpBXServices from '../services/http/HttpBX';
 import UserFilterSearch from '../typification/rest/user/UserFilterSearch';
-import SnackBarService from '../services/snack-bar/snack-bar.service';
 import { iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '../typification/rest/user/user';
 import { iBXRestAnswer } from '../typification/rest/base/answer';
+import { BXRestUserMap } from '../map/user';
 import * as i0 from "@angular/core";
 export declare class BXRestUser {
     private http;
-    private snackBar;
+    private BXRestUserMap;
     url: {
         admin: string[];
         get: string[];
@@ -26,14 +26,14 @@ export declare class BXRestUser {
             start: 0;
         };
     };
-    constructor(http: HttpBXServices, snackBar: SnackBarService);
+    constructor(http: HttpBXServices, BXRestUserMap: BXRestUserMap);
     admin(): import("rxjs").Observable<iBXRestAnswer<boolean> | undefined>;
-    get(params?: iBXGetParam): import("rxjs").Observable<iBXRestAnswer<iBXRestUserHttp[]> | undefined>;
+    get(params?: iBXRestParamUserGet): import("rxjs").Observable<iBXRestAnswer<iBXRestUserHttp[]> | undefined>;
     current(): import("rxjs").Observable<iBXRestAnswer<iBXRestUserHttp> | undefined>;
-    access(access: string[], textError?: string): import("rxjs").Observable<iBXRestAnswer<iBXRestAnswer<boolean> | undefined> | undefined>;
+    update(user: iBXRestUser, fieldUpdate: string[]): import("rxjs").Observable<iBXRestAnswer<iBXRestUserHttp[]> | undefined>;
     search(params: string | UserFilterSearch): import("rxjs").Observable<iBXRestAnswer<iBXRestAnswer<iBXRestUserHttp[]>> | undefined>;
+    access(access: string[]): import("rxjs").Observable<iBXRestAnswer<iBXRestAnswer<boolean> | undefined> | undefined>;
     fields(): import("rxjs").Observable<iBXRestAnswer<iBXRestAnswer<iBXRestUserHttpField>> | undefined>;
-    update(user: iBXRestUser, fieldUpdate: string[]): import("rxjs").Observable<iBXRestAnswer<iBXRestUserHttp[]> | undefined> | import("rxjs").Observable<{}>;
     private setDefParam;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestUser, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestUser>;

package/request-navvy/bizproc/workflow.d.ts

@@ -0,0 +1,12 @@
+import { iBXRestParamBizprocWorkflowStart } from '../../typification/rest/bizproc/workflow/start';
+import { BXRestBizprocWorkflow } from '../../request/bizproc/workflow';
+import { Navvy } from '../../services/navvy';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyBizprocWorkflow {
+    private BXRestBizprocWorkflow;
+    private Navvy;
+    constructor(BXRestBizprocWorkflow: BXRestBizprocWorkflow, Navvy: Navvy);
+    start(param: iBXRestParamBizprocWorkflowStart): import("rxjs").Observable<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyBizprocWorkflow, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyBizprocWorkflow>;
+}

package/request-navvy/bizproc.d.ts

@@ -0,0 +1,24 @@
+import { BXRestNavvyLists } from './lists';
+import { Observable } from 'rxjs';
+import { BXRestNavvyBizprocWorkflow } from './bizproc/workflow';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyBizproc {
+    workflow: BXRestNavvyBizprocWorkflow;
+    private BXRestNavvyLists;
+    constructor(workflow: BXRestNavvyBizprocWorkflow, BXRestNavvyLists: BXRestNavvyLists);
+    /**
+     * Метод по запуску бизнес процессов из ленты
+     *
+     * @param id
+     * @param parametersElement
+     * @param parametersBizproc
+     * @param templateIDs
+     */
+    startProcFormNewsFeed(id: number, parametersElement: {
+        [key: string]: string;
+    }, parametersBizproc: {
+        [key: string]: string;
+    }, templateIDs: number[]): Observable<boolean | (string | undefined)[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyBizproc, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyBizproc>;
+}

package/request-navvy/disk/file.d.ts

@@ -1,18 +1,16 @@
 import { BaseServices } from '../../services/base';
 import { BXRestDiskFile } from '../../request/disk/file';
+import { Navvy } from '../../services/navvy';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyDiskFile extends BaseServices {
     private BXRestDiskFile;
-    constructor(BXRestDiskFile: BXRestDiskFile);
-    get(id: number): import("rxjs").Observable<(import("../../typification/rest/base/answer").iBXRestAnswer<import("../../typification/rest/disk/file").iBXRestFileHttp> & {
-        result: import("../../typification/rest/disk/file").iBXRestFileHttp & {
-            SIZE: number;
-        };
+    private Navvy;
+    constructor(BXRestDiskFile: BXRestDiskFile, Navvy: Navvy);
+    get(id: number): import("rxjs").Observable<(import("../../typification/rest/disk/file").iBXRestFileHttp & {
+        SIZE: number;
     }) | undefined>;
-    markDel(id: number): import("rxjs").Observable<(import("../../typification/rest/base/answer").iBXRestAnswer<import("../../typification/rest/disk/file").iBXRestFileHttp> & {
-        result: import("../../typification/rest/disk/file").iBXRestFileHttp & {
-            SIZE: number;
-        };
+    markDel(id: number): import("rxjs").Observable<(import("../../typification/rest/disk/file").iBXRestFileHttp & {
+        SIZE: number;
     }) | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDiskFile, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDiskFile>;

package/request-navvy/disk/folder.d.ts

@@ -1,10 +1,12 @@
 import BXRestMapDiskFolder from '../../map/disk/folder';
 import { BXRestDiskFolder } from '../../request/disk/folder';
+import { Navvy } from '../../services/navvy';
 import * as i0 from "@angular/core";
 export declare class BXRestDiskNavvyFolder {
     private BXRestDiskFolder;
     private BXRestMapDiskFolder;
-    constructor(BXRestDiskFolder: BXRestDiskFolder, BXRestMapDiskFolder: BXRestMapDiskFolder);
+    private Navvy;
+    constructor(BXRestDiskFolder: BXRestDiskFolder, BXRestMapDiskFolder: BXRestMapDiskFolder, Navvy: Navvy);
     getchildren(id: number): import("rxjs").Observable<import("../../typification/rest/disk/map").iBXRestFileAndFolderMap>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDiskNavvyFolder, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDiskNavvyFolder>;

package/request-navvy/disk/storage.d.ts

@@ -1,12 +1,15 @@
 import { BXRestDiskStorage } from '../../request/disk/storage';
 import BXRestMapDiskStorage from '../../map/disk/storage';
 import { iBXRestParamUploadFile } from '../../typification/rest/disk/storage/uploadfile';
+import { Navvy } from '../../services/navvy';
+import { iBXRestFolderInfo } from '../../typification/rest/disk/folder';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyDiskStorage {
     private BXRestDiskStorage;
     private BXRestMapDiskStorage;
-    constructor(BXRestDiskStorage: BXRestDiskStorage, BXRestMapDiskStorage: BXRestMapDiskStorage);
-    getforapp(): import("rxjs").Observable<import("../../typification/rest/disk/folder").iBXRestFolderInfo | undefined>;
+    private Navvy;
+    constructor(BXRestDiskStorage: BXRestDiskStorage, BXRestMapDiskStorage: BXRestMapDiskStorage, Navvy: Navvy);
+    getforapp(): import("rxjs").Observable<iBXRestFolderInfo | undefined>;
     getchildren(param: {
         id: number;
         filter?: any;

package/request-navvy/lists/element.d.ts

@@ -1,12 +1,16 @@
 import { iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
 import { BXRestListsElement } from '../../request/lists/element';
 import BXRestListsElementMap from '../../map/lists/element';
+import { Navvy } from '../../services/navvy';
+import { iBXRestParamListsElementAdd } from '../../typification/rest/lists/element/add';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyListsElement {
     private BXRestListsElement;
     private BXRestMap;
-    constructor(BXRestListsElement: BXRestListsElement, BXRestMap: BXRestListsElementMap);
-    get(pram: iBXRestParamListsElementGet): import("rxjs").Observable<import("../../typification/rest/lists/element/get").iBXRestListsElement[] | undefined>;
+    private Navvy;
+    constructor(BXRestListsElement: BXRestListsElement, BXRestMap: BXRestListsElementMap, Navvy: Navvy);
+    get(param: iBXRestParamListsElementGet): import("rxjs").Observable<import("../../typification/rest/lists/element/get").iBXRestListsElement[] | undefined>;
+    add(param: iBXRestParamListsElementAdd): import("rxjs").Observable<number | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyListsElement, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyListsElement>;
 }

package/request-navvy/lists.d.ts

@@ -1,14 +1,7 @@
 import { BXRestNavvyListsElement } from './lists/element';
 import * as i0 from "@angular/core";
-export default class BXRestNavvyLists {
+export declare class BXRestNavvyLists {
     element: BXRestNavvyListsElement;
-    url: {
-        add: string[];
-        delete: string[];
-        get: string[];
-        update: string[];
-        getIblockTypeId: string[];
-    };
     constructor(element: BXRestNavvyListsElement);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyLists, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyLists>;

package/request-navvy/tasks/task.d.ts

@@ -1,16 +1,26 @@
 import SnackBarService from '../../services/snack-bar/snack-bar.service';
-import { iBXRestParamTaskAdd } from '../../typification/rest/task/fieldsForSend';
 import { BXRestTaskMap } from '../../map/task';
 import { BXRestTasksTask } from '../../request/tasks/task';
+import { iBXRestTaskFieldsName } from '../../typification/rest/task/base/fieldsName';
+import { iBXRestParamTaskAdd } from '../../typification/rest/tasks/task/add';
+import iBXRestParamTaskGet from '../../typification/rest/tasks/task/get';
+import { Navvy } from '../../services/navvy';
+import { iBXRestParamTasksList } from '../../typification/rest/tasks/task/list';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyTasksTask {
-    private BXRestTasks;
+    private BXRestTasksTask;
     private snackBar;
     private taskMap;
-    constructor(BXRestTasks: BXRestTasksTask, snackBar: SnackBarService, taskMap: BXRestTaskMap);
+    private Navvy;
+    def: {
+        select: iBXRestTaskFieldsName[];
+    };
+    constructor(BXRestTasksTask: BXRestTasksTask, snackBar: SnackBarService, taskMap: BXRestTaskMap, Navvy: Navvy);
     add(param: {
         fields: iBXRestParamTaskAdd;
     }): import("rxjs").Observable<import("../../typification/rest/task/task").iBXRestTask | undefined>;
+    get(requestArray: iBXRestParamTaskGet): import("rxjs").Observable<import("../../typification/rest/task/task").iBXRestTask | undefined>;
+    list(param?: iBXRestParamTasksList): import("rxjs").Observable<import("../../typification/rest/task/task").iBXRestTask[] | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyTasksTask, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyTasksTask>;
 }

package/request-navvy/user.d.ts

@@ -1,19 +1,22 @@
-import { Observable } from 'rxjs';
-import { Store } from '@ngrx/store';
-import { storeUsers } from '../store/users';
 import { BXRestUser } from '../request/user';
 import { BXRestUserMap } from '../map/user';
+import { iBXRestParamUserGet } from '../typification/rest/user/get';
+import { Navvy } from '../services/navvy';
+import { iBXRestUser } from '../typification/rest/user/user';
+import UserFilterSearch from '../typification/rest/user/UserFilterSearch';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyUser {
     private BXRestUser;
-    private store;
     private BXRestUserMap;
-    user$: Observable<storeUsers>;
-    constructor(BXRestUser: BXRestUser, store: Store<{
-        users: storeUsers;
-    }>, BXRestUserMap: BXRestUserMap);
-    current(update?: boolean): Observable<import("../typification/rest/user/user").iBXRestUser | undefined>;
+    private Navvy;
+    constructor(BXRestUser: BXRestUser, BXRestUserMap: BXRestUserMap, Navvy: Navvy);
+    get(params?: iBXRestParamUserGet): import("rxjs").Observable<import("../typification/rest/user/user").iBXRestUserHttp[] | undefined>;
+    current(update?: boolean): import("rxjs").Observable<iBXRestUser | undefined>;
+    update(user: iBXRestUser, fieldUpdate: string[]): import("rxjs").Observable<import("../typification/rest/user/user").iBXRestUserHttp[] | undefined>;
     private self;
+    search(params: string | UserFilterSearch): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<import("../typification/rest/user/user").iBXRestUserHttp[]> | undefined>;
+    access(access: string[]): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<boolean> | undefined>;
+    fields(): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<import("../typification/rest/user/user").iBXRestUserHttpField> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyUser, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyUser>;
 }

package/rest.d.ts

@@ -1,19 +1,22 @@
 import { BXRestUser } from './request/user';
-import BXRestLists from './request/lists';
-import BXRestListsMap from './map/lists';
-import BXRestNavvyLists from './request-navvy/lists';
-import { BXRestNavvyTasks } from './request-navvy/tasks';
+import { BXRestLists } from './request/lists';
+import { BXRestMapLists } from './map/lists';
 import { BXRestTasks } from './request/tasks';
-import { BXRestNavvyUser } from './request-navvy/user';
 import { BXRestDisk } from './request/disk';
+import { BXRestBizproc } from './request/bizproc';
+import { BXRestNavvyLists } from './request-navvy/lists';
+import { BXRestNavvyTasks } from './request-navvy/tasks';
+import { BXRestNavvyUser } from './request-navvy/user';
 import { BXRestNavvyDisk } from './request-navvy/disk';
+import { BXRestNavvyBizproc } from './request-navvy/bizproc';
 import * as i0 from "@angular/core";
 export declare class BXRest {
     user: BXRestUser;
     lists: BXRestLists;
     tasks: BXRestTasks;
     disk: BXRestDisk;
-    constructor(user: BXRestUser, lists: BXRestLists, tasks: BXRestTasks, disk: BXRestDisk);
+    bizproc: BXRestBizproc;
+    constructor(user: BXRestUser, lists: BXRestLists, tasks: BXRestTasks, disk: BXRestDisk, bizproc: BXRestBizproc);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRest, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRest>;
 }
@@ -22,13 +25,14 @@ export declare class BXRestNavvy {
     lists: BXRestNavvyLists;
     tasks: BXRestNavvyTasks;
     disk: BXRestNavvyDisk;
-    constructor(user: BXRestNavvyUser, lists: BXRestNavvyLists, tasks: BXRestNavvyTasks, disk: BXRestNavvyDisk);
+    bizproc: BXRestNavvyBizproc;
+    constructor(user: BXRestNavvyUser, lists: BXRestNavvyLists, tasks: BXRestNavvyTasks, disk: BXRestNavvyDisk, bizproc: BXRestNavvyBizproc);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvy, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvy>;
 }
 export declare class BXRestMap {
-    lists: BXRestListsMap;
-    constructor(lists: BXRestListsMap);
+    lists: BXRestMapLists;
+    constructor(lists: BXRestMapLists);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMap, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMap>;
 }

package/services/http/HttpBX.d.ts

@@ -1,10 +1,10 @@
 import { Observable } from 'rxjs';
 import { iHttpParamSettings } from '../../typification/rest/settings';
-import BaseHttpServices from '../../services/http/http';
+import { HttpServices } from './http';
 import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp } from '../../typification/rest/batch/batchRequestParam';
 import { iBXRestAnswer } from '../../typification/rest/base/answer';
 import * as i0 from "@angular/core";
-export default class HttpBXServices extends BaseHttpServices {
+export default class HttpBXServices extends HttpServices {
     timeNowOnServer(): Observable<Date | undefined>;
     /**
      * Это пиздец а не метод
@@ -12,10 +12,10 @@ export default class HttpBXServices extends BaseHttpServices {
      */
     branch<T, A>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): Observable<iBatchRequestAnswer<A>[] | undefined>;
     prepareBatch<T>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): iBatchRequestParamHttp;
-    post<T>(name: string[], params?: any, textError?: string, settings?: iHttpParamSettings): Observable<iBXRestAnswer<T> | undefined>;
-    get<T>(name: string[], params?: any, textError?: string, settings?: iHttpParamSettings): Observable<iBXRestAnswer<T> | undefined>;
-    httpPost<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
-    httpGet<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    post<T>(name: string[], params?: any, settings?: iHttpParamSettings): Observable<iBXRestAnswer<T> | undefined>;
+    get<T>(name: string[], params?: any, settings?: iHttpParamSettings): Observable<iBXRestAnswer<T> | undefined>;
+    httpPost<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
     getNameMethod(arr: string[]): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpBXServices, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HttpBXServices>;

package/services/http/base/base.d.ts

@@ -2,15 +2,15 @@ import { iHttpParamSettings } from '../../../typification/rest/settings';
 import { HttpClient } from '@angular/common/http';
 import SnackBarService from '../../../services/snack-bar/snack-bar.service';
 import { Observable } from 'rxjs';
-import { HttpData } from '../../../services/http/HttpData';
+import { HttpData } from '../HttpData';
 import * as i0 from "@angular/core";
 export declare abstract class BaseHttp extends HttpData {
     http: HttpClient;
     snackBar: SnackBarService;
     protected constructor(http: HttpClient, snackBar: SnackBarService);
-    abstract httpGet<T>(url: string, params: any, textError: string, settings: iHttpParamSettings): Observable<T | undefined>;
-    abstract httpPost<T>(url: string, params: any, textError: string, settings: iHttpParamSettings): Observable<T | undefined>;
-    handleError<T>(result?: T, textError?: string): (error: Error) => Observable<T>;
+    abstract httpGet<T>(url: string, params: any, settings: iHttpParamSettings): Observable<T | undefined>;
+    abstract httpPost<T>(url: string, params: any, settings: iHttpParamSettings): Observable<T | undefined>;
+    handleError<T>(result?: T): (error: Error) => Observable<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttp, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseHttp>;
 }

package/services/http/base/http.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { iHttpParamSettings } from '../../../typification/rest/settings';
-import { BaseHttp } from '../../../services/http/base/base';
+import { BaseHttp } from './base';
 export declare class BaseHttpServices extends BaseHttp {
-    httpGet<T>(url: string, params?: {}, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
-    httpPost<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: {}, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpPost<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
 }

package/services/http/http.d.ts

@@ -3,22 +3,13 @@ import { HttpClient } from '@angular/common/http';
 import SnackBarService from '../../services/snack-bar/snack-bar.service';
 import SessionKeyServices from '../../services/http/sessionKey';
 import { iHttpParamSettings } from '../../typification/rest/settings';
-import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp } from '../../typification/rest/batch/batchRequestParam';
 import { BaseHttpServices } from './base/http';
 import * as i0 from "@angular/core";
-export default class HttpServices extends BaseHttpServices {
+export declare class HttpServices extends BaseHttpServices {
     session: SessionKeyServices;
     constructor(http: HttpClient, snackBar: SnackBarService, session: SessionKeyServices);
-    timeNowOnServer(): Observable<Date | undefined>;
-    /**
-     * Это пиздец а не метод
-     * @param param
-     */
-    branch<T, A>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): Observable<iBatchRequestAnswer<A>[] | undefined>;
-    prepareBatch<T>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): iBatchRequestParamHttp;
-    httpPost<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
-    httpGet<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
-    getNameMethod(arr: string[]): string;
+    httpPost<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpServices, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HttpServices>;
 }