bx-rest 0.0.34 → 0.1.0

package/functions/mapResult.d.ts

@@ -1,2 +1,4 @@
-import iHttpAnswerBX from '../typification/rest/base/httpAnswerBX';
-export declare function mapResult<T>(v: iHttpAnswerBX<T> | undefined): T | undefined;
+import { iBXRestAnswer } from '../typification/rest/base/answer';
+export declare function BXRestMapResult<T>(v: iBXRestAnswer<T>): NonNullable<T>;
+export declare function BXRestMapResult(v: undefined): undefined;
+export declare function BXRestMapResult<T>(v: iBXRestAnswer<T> | undefined): T | undefined;

package/map/disk/base.d.ts

@@ -0,0 +1,12 @@
+import BaseMapServices from '../base';
+import { iBXRestFile, iBXRestFileHttp } from '../../typification/rest/disk/file';
+import { iBXRestFolder, iBXRestFolderHttp } from '../../typification/rest/disk/folder';
+import { iBXRestFileAndFolderMap } from '../../typification/rest/disk/map';
+import * as i0 from "@angular/core";
+export default class BXRestMapDiskBase extends BaseMapServices {
+    separationFoldersAndFiles(arr: (iBXRestFolderHttp | iBXRestFileHttp)[]): iBXRestFileAndFolderMap;
+    instanceOfiFile(object: any): object is iBXRestFile;
+    instanceOfiFolder(object: any): object is iBXRestFolder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapDiskBase, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapDiskBase>;
+}

package/map/disk/folder.d.ts

@@ -0,0 +1,9 @@
+import { iBXRestFolderHttp } from '../../typification/rest/disk/folder';
+import { iBXRestFileHttp } from '../../typification/rest/disk/file';
+import BXRestMapDiskBase from './base';
+import * as i0 from "@angular/core";
+export default class BXRestMapDiskFolder extends BXRestMapDiskBase {
+    getContent(arr: (iBXRestFolderHttp | iBXRestFileHttp)[]): import("../../typification/rest/disk/map").iBXRestFileAndFolderMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapDiskFolder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapDiskFolder>;
+}

package/map/disk/storage.d.ts

@@ -0,0 +1,9 @@
+import BXRestMapDiskBase from './base';
+import { iBXRestFolderHttp } from '../../typification/rest/disk/folder';
+import { iBXRestFileHttp } from '../../typification/rest/disk/file';
+import * as i0 from "@angular/core";
+export default class BXRestMapDiskStorage extends BXRestMapDiskBase {
+    getchildren(arr: (iBXRestFolderHttp | iBXRestFileHttp)[]): import("../../typification/rest/disk/map").iBXRestFileAndFolderMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapDiskStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapDiskStorage>;
+}

package/map/lists/element.d.ts

@@ -1,8 +1,8 @@
 import BaseMapServices from '../base';
 import { iBXRestHttpListsElement, iBXRestListsElement } from '../../typification/rest/lists/element/get';
 import * as i0 from "@angular/core";
-export default class BXRestListsElementMap extends BaseMapServices {
-    get(item: iBXRestHttpListsElement): iBXRestListsElement;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestListsElementMap, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestListsElementMap>;
+export default class BXRestMapListsElement extends BaseMapServices {
+    get(items: iBXRestHttpListsElement[]): iBXRestListsElement[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapListsElement, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapListsElement>;
 }

package/map/lists.d.ts

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

package/map/task.d.ts

@@ -0,0 +1,8 @@
+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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestTaskMap, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestTaskMap>;
+}

package/map/user.d.ts

@@ -0,0 +1,12 @@
+import BaseMapServices from './base';
+import { iBXRestUser, iBXRestUserHttp } from '../typification/rest/user/user';
+import * as i0 from "@angular/core";
+export declare class BXRestUserMap extends BaseMapServices {
+    current(user: iBXRestUserHttp): iBXRestUser;
+    BXtoHttp(user: iBXRestUser): iBXRestUserHttp;
+    getFIO(user: iBXRestUser): string;
+    getFI(user: iBXRestUser): string;
+    getFIOShort(user: iBXRestUser): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestUserMap, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestUserMap>;
+}

package/package.json

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

package/public-api.d.ts

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

package/request/disk/file.d.ts

@@ -0,0 +1,25 @@
+import HttpBXServices from '../../services/http/HttpBX';
+import { iBXRestFileHttp } from '../../typification/rest/disk/file';
+import * as i0 from "@angular/core";
+export declare class BXRestDiskFile {
+    private http;
+    url: {
+        getfields: string[];
+        get: string[];
+        rename: string[];
+        copyto: string[];
+        moveto: string[];
+        delete: string[];
+        markdeleted: string[];
+        restore: string[];
+        uploadversion: string[];
+        getVersions: string[];
+        restoreFromVersion: string[];
+        getExternalLink: string[];
+    };
+    constructor(http: HttpBXServices);
+    get(id: number): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestFileHttp> | undefined>;
+    markDel(id: number): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestFileHttp> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDiskFile, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDiskFile>;
+}

package/request/disk/folder.d.ts

@@ -0,0 +1,26 @@
+import HttpBXServices from '../../services/http/HttpBX';
+import { iBXRestFolderHttp } from '../../typification/rest/disk/folder';
+import { iBXRestFileHttp } from '../../typification/rest/disk/file';
+import * as i0 from "@angular/core";
+export declare class BXRestDiskFolder {
+    private http;
+    url: {
+        getfields: string[];
+        get: string[];
+        getchildren: string[];
+        addsubfolder: string[];
+        copyto: string[];
+        moveto: string[];
+        rename: string[];
+        deletetree: string[];
+        markdeleted: string[];
+        restore: string[];
+        uploadfile: string[];
+        getExternalLink: string[];
+    };
+    constructor(http: HttpBXServices);
+    uploadfile(id: number, fileContent: string[]): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<unknown> | undefined>;
+    getchildren(id: number): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<(iBXRestFolderHttp | iBXRestFileHttp)[]> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDiskFolder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDiskFolder>;
+}

package/request/disk/storage.d.ts

@@ -0,0 +1,34 @@
+import HttpBXServices from '../../services/http/HttpBX';
+import { iBXRestFile, iBXRestFileHttp } from '../../typification/rest/disk/file';
+import { iBXRestFolderHttp, iBXRestFolderInfo } from '../../typification/rest/disk/folder';
+import { iBXRestParamUploadFile } from '../../typification/rest/disk/storage/uploadfile';
+import * as i0 from "@angular/core";
+export declare class BXRestDiskStorage {
+    private http;
+    url: {
+        getfields: string[];
+        get: string[];
+        rename: string[];
+        getlist: string[];
+        gettypes: string[];
+        addfolder: string[];
+        getchildren: string[];
+        uploadfile: string[];
+        getforapp: string[];
+    };
+    constructor(http: HttpBXServices);
+    getforapp(): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestFolderInfo> | undefined>;
+    getchildren(param: {
+        id: number;
+        filter?: any;
+    }): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<(iBXRestFolderHttp | iBXRestFileHttp)[]> | undefined>;
+    addfolder(param: {
+        id: number;
+        data: {
+            NAME: string;
+        };
+    }): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<any> | undefined>;
+    uploadfile(param: iBXRestParamUploadFile): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestFile> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDiskStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDiskStorage>;
+}

package/request/disk.d.ts

@@ -0,0 +1,10 @@
+import { BXRestDiskFile } from './disk/file';
+import { BXRestDiskFolder } from './disk/folder';
+import * as i0 from "@angular/core";
+export declare class BXRestDisk {
+    file: BXRestDiskFile;
+    folder: BXRestDiskFolder;
+    constructor(file: BXRestDiskFile, folder: BXRestDiskFolder);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDisk, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDisk>;
+}

package/request/lists/element.d.ts

@@ -1,10 +1,8 @@
 import HttpBXServices from '../../services/http/HttpBX';
-import BXRestListsElementMap from '../../map/lists/element';
-import { iBXRestListsElement, iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
+import { iBXRestHttpListsElement, iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
 import * as i0 from "@angular/core";
 export declare class BXRestListsElement {
     private http;
-    private mapResult;
     url: {
         add: string[];
         delete: string[];
@@ -12,8 +10,8 @@ export declare class BXRestListsElement {
         update: string[];
         getFileUrl: string[];
     };
-    constructor(http: HttpBXServices, mapResult: BXRestListsElementMap);
-    get(pram: iBXRestParamListsElementGet): import("rxjs").Observable<import("../../typification/rest/base/httpAnswerBX").default<iBXRestListsElement[]> | undefined>;
+    constructor(http: HttpBXServices);
+    get(pram: iBXRestParamListsElementGet): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestHttpListsElement[]> | undefined>;
     customPipe(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestListsElement, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestListsElement>;

package/request/tasks/task.d.ts

@@ -0,0 +1,55 @@
+import HttpBXServices from '../../services/http/HttpBX';
+import { iBXRestParamTaskAdd } from '../../typification/rest/task/fieldsForSend';
+import { iBXRestHttpTask } from '../../typification/rest/task/task';
+import * as i0 from "@angular/core";
+export declare class BXRestTasksTask {
+    private http;
+    url: {
+        add: string[];
+        approve: string[];
+        complete: string[];
+        counters: {
+            get: string[];
+        };
+        deger: string[];
+        delegate: string[];
+        delete: string[];
+        disapprove: string[];
+        favorite: {
+            add: string[];
+            delete: string[];
+        };
+        files: {
+            attach: string[];
+        };
+        get: string[];
+        getFields: string[];
+        getaccess: string[];
+        history: {
+            list: string[];
+        };
+        list: string[];
+        pause: string[];
+        renew: string[];
+        start: string[];
+        startwatch: string[];
+        stopwatch: string[];
+        update: string[];
+        result: {
+            list: string[];
+            addFromComment: string[];
+            deleteFromComment: string[];
+        };
+        planner: {
+            getlist: string[];
+        };
+    };
+    constructor(http: HttpBXServices);
+    add(param: {
+        fields: iBXRestParamTaskAdd;
+    }): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<{
+        task: iBXRestHttpTask;
+    }> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestTasksTask, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestTasksTask>;
+}

package/request/tasks.d.ts

@@ -0,0 +1,8 @@
+import { BXRestTasksTask } from './tasks/task';
+import * as i0 from "@angular/core";
+export declare class BXRestTasks {
+    task: BXRestTasksTask;
+    constructor(task: BXRestTasksTask);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestTasks, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestTasks>;
+}

package/request/user.d.ts

@@ -1,19 +1,13 @@
-import { Observable } from 'rxjs';
 import { iBXGetParam } from '../typification/rest/user/get';
 import HttpBXServices from '../services/http/HttpBX';
 import UserFilterSearch from '../typification/rest/user/UserFilterSearch';
-import { Store } from '@ngrx/store';
-import { storeUsers } from '../store/users';
-import { BitrixApiUserMapServices } from '../services/map/rest/user';
 import SnackBarService from '../services/snack-bar/snack-bar.service';
-import iHttpAnswerBX from '../typification/rest/base/httpAnswerBX';
 import { iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '../typification/rest/user/user';
+import { iBXRestAnswer } from '../typification/rest/base/answer';
 import * as i0 from "@angular/core";
 export declare class BXRestUser {
     private http;
     private snackBar;
-    private store;
-    private userMap;
     url: {
         admin: string[];
         get: string[];
@@ -32,19 +26,14 @@ export declare class BXRestUser {
             start: 0;
         };
     };
-    user$: Observable<storeUsers>;
-    constructor(http: HttpBXServices, snackBar: SnackBarService, store: Store<{
-        users: storeUsers;
-    }>, userMap: BitrixApiUserMapServices);
-    admin(): Observable<typeof import("../functions/mapResult").mapResult | iHttpAnswerBX<boolean> | undefined>;
-    get(params?: iBXGetParam): Observable<iHttpAnswerBX<iBXRestUser[]> | undefined>;
-    current(update?: boolean): Observable<typeof import("../functions/mapResult").mapResult | iBXRestUser | iHttpAnswerBX<iBXRestUserHttp> | iHttpAnswerBX<iBXRestUser> | undefined>;
-    private getSelfHttp;
-    access(access: string[], textError?: string): Observable<typeof import("../functions/mapResult").mapResult | iHttpAnswerBX<iHttpAnswerBX<boolean> | undefined> | undefined>;
-    private saveArrUser;
-    search(params: string | UserFilterSearch): Observable<typeof import("../functions/mapResult").mapResult | iHttpAnswerBX<iHttpAnswerBX<iBXRestUserHttp[]>> | undefined>;
-    fields(): Observable<typeof import("../functions/mapResult").mapResult | iHttpAnswerBX<iHttpAnswerBX<iBXRestUserHttpField>> | undefined>;
-    update(user: iBXRestUser, fieldUpdate: string[]): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined> | Observable<{}>;
+    constructor(http: HttpBXServices, snackBar: SnackBarService);
+    admin(): import("rxjs").Observable<iBXRestAnswer<boolean> | undefined>;
+    get(params?: iBXGetParam): 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>;
+    search(params: string | UserFilterSearch): import("rxjs").Observable<iBXRestAnswer<iBXRestAnswer<iBXRestUserHttp[]>> | 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/disk/file.d.ts

@@ -0,0 +1,19 @@
+import { BaseServices } from '../../services/base';
+import { BXRestDiskFile } from '../../request/disk/file';
+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;
+        };
+    }) | 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;
+        };
+    }) | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDiskFile, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDiskFile>;
+}

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

@@ -0,0 +1,11 @@
+import BXRestMapDiskFolder from '../../map/disk/folder';
+import { BXRestDiskFolder } from '../../request/disk/folder';
+import * as i0 from "@angular/core";
+export declare class BXRestDiskNavvyFolder {
+    private BXRestDiskFolder;
+    private BXRestMapDiskFolder;
+    constructor(BXRestDiskFolder: BXRestDiskFolder, BXRestMapDiskFolder: BXRestMapDiskFolder);
+    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/operation.d.ts

@@ -0,0 +1,23 @@
+import { BXRestDiskNavvyFolder } from './folder';
+import { BXRestNavvyDiskFile } from './file';
+import { BXRestNavvyDiskStorage } from './storage';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyDiskOperation {
+    folder: BXRestDiskNavvyFolder;
+    disk: BXRestNavvyDiskFile;
+    private storage;
+    constructor(folder: BXRestDiskNavvyFolder, disk: BXRestNavvyDiskFile, storage: BXRestNavvyDiskStorage);
+    loadFileInAppFolder(file: {
+        name: string;
+        val: string;
+    }): import("rxjs").Observable<import("../../typification/rest/disk/file").iBXRestFile | undefined>;
+    getOfCreateRootContentFolderApp(folderName: string): import("rxjs").Observable<import("../../typification/rest/disk/map").iBXRestFileAndFolderMap | undefined>;
+    getRootFoldersApp(): import("rxjs").Observable<import("../../typification/rest/disk/map").iBXRestFileAndFolderMap | undefined>;
+    /**
+     * Получать или создать папку, если её нет, с определенным именем для приложения
+     * @param folderName
+     */
+    getOfCreateRootFolderApp(folderName: string): import("rxjs").Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDiskOperation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDiskOperation>;
+}

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

@@ -0,0 +1,23 @@
+import { BXRestDiskStorage } from '../../request/disk/storage';
+import BXRestMapDiskStorage from '../../map/disk/storage';
+import { iBXRestParamUploadFile } from '../../typification/rest/disk/storage/uploadfile';
+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>;
+    getchildren(param: {
+        id: number;
+        filter?: any;
+    }): import("rxjs").Observable<import("../../typification/rest/disk/map").iBXRestFileAndFolderMap>;
+    addfolder(param: {
+        id: number;
+        data: {
+            NAME: string;
+        };
+    }): import("rxjs").Observable<any>;
+    uploadfile(param: iBXRestParamUploadFile): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<import("../../typification/rest/disk/file").iBXRestFile> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDiskStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDiskStorage>;
+}

package/request-navvy/disk.d.ts

@@ -0,0 +1,12 @@
+import { BXRestNavvyDiskFile } from './disk/file';
+import { BXRestDiskNavvyFolder } from './disk/folder';
+import { BXRestNavvyDiskOperation } from './disk/operation';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyDisk {
+    file: BXRestNavvyDiskFile;
+    folder: BXRestDiskNavvyFolder;
+    operation: BXRestNavvyDiskOperation;
+    constructor(file: BXRestNavvyDiskFile, folder: BXRestDiskNavvyFolder, operation: BXRestNavvyDiskOperation);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDisk, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDisk>;
+}

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

@@ -0,0 +1,12 @@
+import { iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
+import { BXRestListsElement } from '../../request/lists/element';
+import BXRestListsElementMap from '../../map/lists/element';
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyListsElement, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyListsElement>;
+}

package/request-navvy/lists.d.ts

@@ -0,0 +1,15 @@
+import { BXRestNavvyListsElement } from './lists/element';
+import * as i0 from "@angular/core";
+export default 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

@@ -0,0 +1,16 @@
+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 * as i0 from "@angular/core";
+export declare class BXRestNavvyTasksTask {
+    private BXRestTasks;
+    private snackBar;
+    private taskMap;
+    constructor(BXRestTasks: BXRestTasksTask, snackBar: SnackBarService, taskMap: BXRestTaskMap);
+    add(param: {
+        fields: iBXRestParamTaskAdd;
+    }): import("rxjs").Observable<import("../../typification/rest/task/task").iBXRestTask | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyTasksTask, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyTasksTask>;
+}

package/request-navvy/tasks.d.ts

@@ -0,0 +1,8 @@
+import { BXRestNavvyTasksTask } from './tasks/task';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyTasks {
+    task: BXRestNavvyTasksTask;
+    constructor(task: BXRestNavvyTasksTask);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyTasks, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyTasks>;
+}

package/request-navvy/user.d.ts

@@ -0,0 +1,19 @@
+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 * 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 self;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyUser, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyUser>;
+}

package/rest.d.ts

@@ -1,10 +1,34 @@
 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 { BXRestTasks } from './request/tasks';
+import { BXRestNavvyUser } from './request-navvy/user';
+import { BXRestDisk } from './request/disk';
+import { BXRestNavvyDisk } from './request-navvy/disk';
 import * as i0 from "@angular/core";
 export declare class BXRest {
     user: BXRestUser;
     lists: BXRestLists;
-    constructor(user: BXRestUser, lists: BXRestLists);
+    tasks: BXRestTasks;
+    disk: BXRestDisk;
+    constructor(user: BXRestUser, lists: BXRestLists, tasks: BXRestTasks, disk: BXRestDisk);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRest, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRest>;
 }
+export declare class BXRestNavvy {
+    user: BXRestNavvyUser;
+    lists: BXRestNavvyLists;
+    tasks: BXRestNavvyTasks;
+    disk: BXRestNavvyDisk;
+    constructor(user: BXRestNavvyUser, lists: BXRestNavvyLists, tasks: BXRestNavvyTasks, disk: BXRestNavvyDisk);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvy>;
+}
+export declare class BXRestMap {
+    lists: BXRestListsMap;
+    constructor(lists: BXRestListsMap);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMap, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMap>;
+}

package/services/http/HttpBX.d.ts

@@ -2,10 +2,8 @@ import { Observable } from 'rxjs';
 import { iHttpParamSettings } from '../../typification/rest/settings';
 import BaseHttpServices from '../../services/http/http';
 import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp } from '../../typification/rest/batch/batchRequestParam';
-import { mapResult } from '../../functions/mapResult';
-import iHttpAnswerBX from '../../typification/rest/base/httpAnswerBX';
+import { iBXRestAnswer } from '../../typification/rest/base/answer';
 import * as i0 from "@angular/core";
-declare type TransformFunction<T, R> = (input: T) => R;
 export default class HttpBXServices extends BaseHttpServices {
     timeNowOnServer(): Observable<Date | undefined>;
     /**
@@ -14,18 +12,11 @@ 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;
-    mapBranchResult<T>(res: iBatchRequestAnswer<T>[]): {
-        [key: string]: T;
-        [key: number]: T;
-    };
-    mapBranchResultWithoutKey<T>(res: iBatchRequestAnswer<T>[]): T[];
-    post<T>(name: string[], params: any, textError: string, mapHttp?: undefined, settings?: iHttpParamSettings): Observable<iHttpAnswerBX<T> | undefined>;
-    post<T, R>(name: string[], params: any, textError: string, mapHttp: TransformFunction<T, R>, settings?: iHttpParamSettings): Observable<iHttpAnswerBX<R> | undefined>;
-    get<T, R = T>(name: string[], params?: any, textError?: string, mapHttp?: TransformFunction<T, R>, settings?: iHttpParamSettings): Observable<typeof mapResult | iHttpAnswerBX<T> | iHttpAnswerBX<R> | undefined>;
+    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>;
     getNameMethod(arr: string[]): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpBXServices, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HttpBXServices>;
 }
-export {};

package/services/http/HttpData.d.ts

@@ -1,13 +1,11 @@
-import { BaseServices } from '../../services/base';
+import { BaseServices } from '../base';
 import { HttpParams } from '@angular/common/http';
 import { iHttpParamSettings } from '../../typification/rest/settings';
-import iHttpAnswerBX from '../../typification/rest/base/httpAnswerBX';
 export declare class HttpData extends BaseServices {
     defSettings: iHttpParamSettings;
     getHttpParamsGet(// не так уж и сложно сделать сложенный HttpParams, да гугл?
     obj: any, sendHttpParams?: HttpParams, thisArray?: boolean, nesting?: string[], _?: iHttpParamSettings): any;
     getHttpParamsPost(obj: any, sendHttpParams?: FormData, thisArray?: boolean, nesting?: string[], settings?: iHttpParamSettings): any;
-    mapResult<T>(v: iHttpAnswerBX<T> | undefined): T | undefined;
     sliceArrayIntoChunks(arr: any[], chunkSize: number): any[][];
     removingMultipleSlashes(str: string): string;
 }

package/services/http/http.d.ts

@@ -16,11 +16,6 @@ export default class HttpServices extends BaseHttpServices {
      */
     branch<T, A>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): Observable<iBatchRequestAnswer<A>[] | undefined>;
     prepareBatch<T>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): iBatchRequestParamHttp;
-    mapBranchResult<T>(res: iBatchRequestAnswer<T>[]): {
-        [key: string]: T;
-        [key: number]: T;
-    };
-    mapBranchResultWithoutKey<T>(res: iBatchRequestAnswer<T>[]): T[];
     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;