bx-rest 0.4.17 → 0.5.1

package/request-navvy/timeman.d.ts

@@ -1,14 +1,13 @@
-import { iBXRestParamTimeManStatus } from '../typification/rest/timeman/status';
-import { Navvy } from '../services/navvy';
-import { BXRestTimeMan } from '../request/timeman';
-import { BXRestMapTimeMan } from '../map/timeman';
-import * as i0 from "@angular/core";
-export declare class BXRestNavvyTimeMan {
-    private BXRestTimeMan;
-    private BXRestMapTimeMan;
-    protected Navvy: Navvy<BXRestTimeMan, BXRestMapTimeMan>;
-    constructor(BXRestTimeMan: BXRestTimeMan, BXRestMapTimeMan: BXRestMapTimeMan);
-    status(param?: iBXRestParamTimeManStatus | undefined): import("../services/Navvy/NavvySimple").NavvySimple<BXRestTimeMan, BXRestMapTimeMan, import("../typification/rest/timeman/status").iBXRestTimeManStatusHttp, import("../typification/rest/timeman/status").iBXRestTimeManStatus | undefined>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyTimeMan, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyTimeMan>;
-}
+import { iBXRestParamTimeManStatus } from '../typification/rest/timeman/status';
+import { Navvy } from '../services/navvy';
+import { BXRestTimeMan } from '../request/timeman';
+import { BXRestMapTimeMan } from '../map/timeman';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyTimeMan {
+    private readonly BXRestTimeMan;
+    private readonly BXRestMapTimeMan;
+    protected Navvy: Navvy<BXRestTimeMan, BXRestMapTimeMan>;
+    status(param?: iBXRestParamTimeManStatus | undefined): import("../services/Navvy/NavvySimple").NavvySimple<BXRestTimeMan, BXRestMapTimeMan, import("../typification/rest/timeman/status").iBXRestTimeManStatusHttp, import("../typification/rest/timeman/status").iBXRestTimeManStatus | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyTimeMan, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyTimeMan>;
+}

package/request-navvy/user/userfield.d.ts

@@ -1,10 +1,9 @@
-import { BXRestUserUserfield } from '../../request/user/userfield';
-import * as i0 from "@angular/core";
-export declare class BXRestNavvyUserUserfield {
-    private BXRestUserUserfield;
-    private Navvy;
-    constructor(BXRestUserUserfield: BXRestUserUserfield);
-    list(): import("../../services/Navvy/NavvySimple").NavvySimple<BXRestUserUserfield, undefined, import("../../typification/rest/user/userfield/list").iBXRestUserUserField[], unknown>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyUserUserfield, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyUserUserfield>;
-}
+import { BXRestUserUserfield } from '../../request/user/userfield';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyUserUserfield {
+    private readonly BXRestUserUserfield;
+    private readonly Navvy;
+    list(): import("../../services/Navvy/NavvySimple").NavvySimple<BXRestUserUserfield, undefined, import("../../typification/rest/user/userfield/list").iBXRestUserUserField[], unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyUserUserfield, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyUserUserfield>;
+}

package/request-navvy/user.d.ts

@@ -1,28 +1,27 @@
-import { BXRestUser } from '../request/user';
-import { iBXRestParamUserGet } from '../typification/rest/user/get';
-import { iBXRestParamUserSearch } from '../typification/rest/user/search';
-import { BXRestNavvyUserUserfield } from './user/userfield';
-import { BXRestMapUser } from '../map/user';
-import * as i0 from "@angular/core";
-export declare class BXRestNavvyUser {
-    private BXRestUserMap;
-    private BXRestUser;
-    userField: BXRestNavvyUserUserfield;
-    def: {
-        params: {
-            ACTIVE: boolean;
-            start: 0;
-        };
-    };
-    private Navvy;
-    constructor(BXRestUserMap: BXRestMapUser, BXRestUser: BXRestUser, userField: BXRestNavvyUserUserfield);
-    admin(): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, boolean, unknown>;
-    get(params?: iBXRestParamUserGet): import("../services/Navvy/NavvyPagNav").NavvyPagNav<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttp, import("../typification/rest/user/user").iBXRestUser, iBXRestParamUserGet>;
-    current(): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttp, import("../typification/rest/user/user").iBXRestUser | undefined>;
-    search(params: iBXRestParamUserSearch): import("../services/Navvy/NavvyPagNav").NavvyPagNav<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttp, import("../typification/rest/user/user").iBXRestUser, iBXRestParamUserSearch>;
-    access(params: string[]): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, boolean, unknown>;
-    fields(): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttpField, unknown>;
-    private setDefParam;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyUser, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyUser>;
-}
+import { BXRestUser } from '../request/user';
+import { iBXRestParamUserGet } from '../typification/rest/user/get';
+import { iBXRestParamUserSearch } from '../typification/rest/user/search';
+import { BXRestNavvyUserUserfield } from './user/userfield';
+import { BXRestMapUser } from '../map/user';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyUser {
+    def: {
+        params: {
+            ACTIVE: boolean;
+            start: 0;
+        };
+    };
+    private readonly BXRestUserMap;
+    private readonly BXRestUser;
+    readonly userField: BXRestNavvyUserUserfield;
+    private readonly Navvy;
+    admin(): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, boolean, unknown>;
+    get(params?: iBXRestParamUserGet): import("../services/Navvy/NavvyPagNav").NavvyPagNav<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttp, import("../typification/rest/user/user").iBXRestUser, iBXRestParamUserGet>;
+    current(): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttp, import("../typification/rest/user/user").iBXRestUser | undefined>;
+    search(params: iBXRestParamUserSearch): import("../services/Navvy/NavvyPagNav").NavvyPagNav<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttp, import("../typification/rest/user/user").iBXRestUser, iBXRestParamUserSearch>;
+    access(params: string[]): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, boolean, unknown>;
+    fields(): import("../services/Navvy/NavvySimple").NavvySimple<BXRestUser, BXRestMapUser, import("../typification/rest/user/user").iBXRestUserHttpField, unknown>;
+    private setDefParam;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyUser, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyUser>;
+}

package/rest/base.d.ts

@@ -0,0 +1,38 @@
+import { BXRestUser } from '../request/user';
+import { BXRestLists } from '../request/lists';
+import { BXRestTask } from '../request/task';
+import { BXRestTasks } from '../request/tasks';
+import { BXRestDisk } from '../request/disk';
+import { BXRestBizProc } from '../request/bizproc';
+import { BXRestLog } from '../request/log';
+import { BXRestCalendar } from '../request/calendar';
+import { BXRestSonetGroup } from '../request/sonet_group';
+import { BXRestServer } from '../request/server';
+import { BXRestDepartment } from '../request/department';
+import { BXRestIm } from '../request/im';
+import { BXRestApp } from '../request/app';
+import { BXRestTimeMan } from '../request/timeman';
+import { iBXRestProfileHttp } from '../typification/rest/profile';
+import { iBXRestBatch, iBXRestParamBatch } from '../typification/rest/batch';
+import * as i0 from "@angular/core";
+export declare class BXRest {
+    private readonly http;
+    readonly user: BXRestUser;
+    readonly lists: BXRestLists;
+    readonly task: BXRestTask;
+    readonly tasks: BXRestTasks;
+    readonly disk: BXRestDisk;
+    readonly bizProc: BXRestBizProc;
+    readonly log: BXRestLog;
+    readonly calendar: BXRestCalendar;
+    readonly sonet_group: BXRestSonetGroup;
+    readonly server: BXRestServer;
+    readonly department: BXRestDepartment;
+    readonly im: BXRestIm;
+    readonly app: BXRestApp;
+    readonly timeMan: BXRestTimeMan;
+    profile(): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<iBXRestProfileHttp> | undefined>;
+    batch<T>(param: iBXRestParamBatch<T>): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<iBXRestBatch<T>> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRest, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRest>;
+}

package/rest/map.d.ts

@@ -0,0 +1,7 @@
+import { BXRestMapLists } from '../map/lists';
+import * as i0 from "@angular/core";
+export declare class BXRestMap {
+    readonly lists: BXRestMapLists;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMap, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMap>;
+}

package/rest/navvy.d.ts

@@ -0,0 +1,43 @@
+import { BXRestMaps } from '../map/rest';
+import { BXRestNavvyUser } from '../request-navvy/user';
+import { BXRestNavvyLists } from '../request-navvy/lists';
+import { BXRestNavvyTask } from '../request-navvy/task';
+import { BXRestNavvyTasks } from '../request-navvy/tasks';
+import { BXRestNavvyDisk } from '../request-navvy/disk';
+import { BXRestNavvyBizProc } from '../request-navvy/bizproc';
+import { BXRestNavvyLog } from '../request-navvy/log';
+import { BXRestNavvyCalendar } from '../request-navvy/calendar';
+import { BXRestNavvySonetGroup } from '../request-navvy/sonet_group';
+import { BXRestNavvyServer } from '../request-navvy/server';
+import { BXRestNavvyDepartment } from '../request-navvy/department';
+import { BXRestNavvyIm } from '../request-navvy/im';
+import { BXRestNavvyApp } from '../request-navvy/app';
+import { BXRestNavvyTimeMan } from '../request-navvy/timeman';
+import { iBXRestNavvyParamBatch } from '../typification/rest/batch';
+import { BXRest } from './base';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvy {
+    readonly user: BXRestNavvyUser;
+    readonly lists: BXRestNavvyLists;
+    readonly task: BXRestNavvyTask;
+    readonly tasks: BXRestNavvyTasks;
+    readonly disk: BXRestNavvyDisk;
+    readonly bizProc: BXRestNavvyBizProc;
+    readonly log: BXRestNavvyLog;
+    readonly calendar: BXRestNavvyCalendar;
+    readonly sonet_group: BXRestNavvySonetGroup;
+    readonly server: BXRestNavvyServer;
+    readonly department: BXRestNavvyDepartment;
+    readonly im: BXRestNavvyIm;
+    readonly app: BXRestNavvyApp;
+    readonly timeMan: BXRestNavvyTimeMan;
+    private readonly BXRest;
+    private readonly BXRestMap;
+    private readonly Navvy;
+    profile(): import("../services/Navvy/NavvySimple").NavvySimple<BXRest, BXRestMaps, import("../typification/rest/profile").iBXRestProfileHttp, import("../typification/rest/profile").iBXRestProfile | undefined>;
+    batch<T, C, M>(param: iBXRestNavvyParamBatch<T, C, M>): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<import("../typification/rest/batch").iBXRestBatch<{
+        [x: string]: any;
+    }>> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvy>;
+}

package/services/Navvy/NavvyAlternativePaginationNavigation.d.ts

@@ -1,14 +1,14 @@
-import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
-import { ReturnTypeNavvy } from './NavvySupport';
-import { iBXRestAlternativePagination } from '../../typification/rest/base/ApiPaginationBX';
-/**
- * Класс-прослойка-обработчик для методов работающих на альтернативной постраничной навигации тика как методы по
- * затраченному времени на задачи https://dev.1c-bitrix.ru/rest_help/tasks/task/elapseditem/index.php
- *
- * не завершенный класс, работаем от частного к общему
- */
-export declare class NavvyAlterPagNav<C, M, T, R, P extends iBXRestAlternativePagination> extends NavvyPagNavBase<C, M, T[], R[], P> {
-    resultAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
-    private resultAllEnd;
-    private mapResultForGetAll;
-}
+import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
+import { ReturnTypeNavvy } from './NavvySupport';
+import { iBXRestAlternativePagination } from '../../typification/rest/base/ApiPaginationBX';
+/**
+ * Класс-прослойка-обработчик для методов работающих на альтернативной постраничной навигации тика как методы по
+ * затраченному времени на задачи https://dev.1c-bitrix.ru/rest_help/tasks/task/elapseditem/index.php
+ *
+ * не завершенный класс, работаем от частного к общему
+ */
+export declare class NavvyAlterPagNav<C, M, T, R, P extends iBXRestAlternativePagination> extends NavvyPagNavBase<C, M, T[], R[], P> {
+    resultAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
+    private resultAllEnd;
+    private mapResultForGetAll;
+}

package/services/Navvy/NavvyPagNav.d.ts

@@ -1,8 +1,8 @@
-import { iBXRestPagination } from '../../typification/rest/base/ApiPaginationBX';
-import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
-import { ReturnTypeNavvy } from './NavvySupport';
-export declare class NavvyPagNav<C, M, T, R, P extends iBXRestPagination> extends NavvyPagNavBase<C, M, T[], R[], P> {
-    resultAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
-    private resultAllEnd;
-    private mapResultForGetAll;
-}
+import { iBXRestPagination } from '../../typification/rest/base/ApiPaginationBX';
+import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
+import { ReturnTypeNavvy } from './NavvySupport';
+export declare class NavvyPagNav<C, M, T, R, P extends iBXRestPagination> extends NavvyPagNavBase<C, M, T[], R[], P> {
+    resultAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
+    private resultAllEnd;
+    private mapResultForGetAll;
+}

package/services/Navvy/NavvyPagNavTasks.d.ts

@@ -1,10 +1,10 @@
-import { iBXRestPagination } from '../../typification/rest/base/ApiPaginationBX';
-import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
-import { ReturnTypeNavvy } from './NavvySupport';
-export declare class NavvyPagNavTasks<C, M, T, R, P extends iBXRestPagination> extends NavvyPagNavBase<C, M, {
-    tasks: T[] | undefined;
-}, R[], P> {
-    resultAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
-    private resultAllEnd;
-    private mapResultForGetAll;
-}
+import { iBXRestPagination } from '../../typification/rest/base/ApiPaginationBX';
+import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
+import { ReturnTypeNavvy } from './NavvySupport';
+export declare class NavvyPagNavTasks<C, M, T, R, P extends iBXRestPagination> extends NavvyPagNavBase<C, M, {
+    tasks: T[] | undefined;
+}, R[], P> {
+    resultAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
+    private resultAllEnd;
+    private mapResultForGetAll;
+}

package/services/Navvy/NavvyPagNavWithUselessKey.d.ts

@@ -1,8 +1,8 @@
-import { iBXRestPagination } from '../../typification/rest/base/ApiPaginationBX';
-import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
-export declare class NavvyPagNavWithUselessKey<C, M, T, R, P extends iBXRestPagination> extends NavvyPagNavBase<C, M, {
-    [key: string]: T;
-}, R[], P> {
-    resultAll(): import("rxjs").Observable<(T | R)[]>;
-    private resultAllEnd;
-}
+import { iBXRestPagination } from '../../typification/rest/base/ApiPaginationBX';
+import { NavvyPagNavBase } from './extends/NavvyPagNavBase';
+export declare class NavvyPagNavWithUselessKey<C, M, T, R, P extends iBXRestPagination> extends NavvyPagNavBase<C, M, {
+    [key: string]: T;
+}, R[], P> {
+    resultAll(): import("rxjs").Observable<(T | R)[]>;
+    private resultAllEnd;
+}

package/services/Navvy/NavvySimple.d.ts

@@ -1,10 +1,10 @@
-import { Observable } from 'rxjs';
-import { iBXRestAnswer } from '../../typification/rest/base/answer';
-import { NavvySupport, ReturnTypeNavvy } from './NavvySupport';
-export declare class NavvySimple<C, M, T, R> extends NavvySupport<C, M, T, R> {
-    func: Observable<iBXRestAnswer<T> | undefined>;
-    map: ((param: T | undefined) => R) | undefined;
-    constructor(requestClass: C, mapClass: M, func: Observable<iBXRestAnswer<T> | undefined>, map?: ((param: T | undefined) => R) | undefined);
-    resultVanilla(): Observable<iBXRestAnswer<T> | undefined>;
-    result(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
-}
+import { Observable } from 'rxjs';
+import { iBXRestAnswer } from '../../typification/rest/base/answer';
+import { NavvySupport, ReturnTypeNavvy } from './NavvySupport';
+export declare class NavvySimple<C, M, T, R> extends NavvySupport<C, M, T, R> {
+    func: Observable<iBXRestAnswer<T> | undefined>;
+    map: ((param: T | undefined) => R) | undefined;
+    constructor(requestClass: C, mapClass: M, func: Observable<iBXRestAnswer<T> | undefined>, map?: ((param: T | undefined) => R) | undefined);
+    resultVanilla(): Observable<iBXRestAnswer<T> | undefined>;
+    result(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
+}

package/services/Navvy/NavvySupport.d.ts

@@ -1,12 +1,12 @@
-import { Observable } from 'rxjs';
-import { iBXRestAnswer } from '../../typification/rest/base/answer';
-export type ReturnTypeNavvy<T, R> = T extends R ? T : R;
-export declare abstract class NavvySupport<C, M, T, R> {
-    requestClass: C;
-    mapClass: M;
-    pageSize: number;
-    protected constructor(requestClass: C, mapClass: M);
-    mapAndError<T>(request: Observable<iBXRestAnswer<T> | undefined>): Observable<T | undefined>;
-    abstract resultVanilla(): Observable<iBXRestAnswer<T> | undefined>;
-    abstract result(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
-}
+import { Observable } from 'rxjs';
+import { iBXRestAnswer } from '../../typification/rest/base/answer';
+export type ReturnTypeNavvy<T, R> = T extends R ? T : R;
+export declare abstract class NavvySupport<C, M, T, R> {
+    requestClass: C;
+    mapClass: M;
+    pageSize: number;
+    protected constructor(requestClass: C, mapClass: M);
+    mapAndError<T>(request: Observable<iBXRestAnswer<T> | undefined>): Observable<T | undefined>;
+    abstract resultVanilla(): Observable<iBXRestAnswer<T> | undefined>;
+    abstract result(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
+}

package/services/Navvy/extends/NavvyPagNavBase.d.ts

@@ -1,16 +1,16 @@
-import { NavvySupport, ReturnTypeNavvy } from '../NavvySupport';
-import { Observable, ReplaySubject } from 'rxjs';
-import { iBXRestAnswer } from '../../../typification/rest/base/answer';
-export declare abstract class NavvyPagNavBase<C, M, T, R, P> extends NavvySupport<C, M, T, R> {
-    protected func: (param: P) => Observable<iBXRestAnswer<T> | undefined>;
-    protected param: P;
-    protected map: ((param: T | undefined) => R | undefined) | undefined;
-    load$: ReplaySubject<number>;
-    constructor(requestClass: C, mapClass: M, func: (param: P) => Observable<iBXRestAnswer<T> | undefined>, param: P, map?: ((param: T | undefined) => R | undefined) | undefined);
-    resultVanilla(): Observable<iBXRestAnswer<T> | undefined>;
-    mapForVanilla(): ReturnTypeNavvy<Observable<iBXRestAnswer<T | undefined>>, Observable<iBXRestAnswer<R | undefined>>>;
-    protected mapForVanillaEnd(func: (param: P) => Observable<iBXRestAnswer<T> | undefined>, param: P): ReturnTypeNavvy<Observable<iBXRestAnswer<T | undefined>>, Observable<iBXRestAnswer<R | undefined>>>;
-    result(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
-    protected resultEnd(func: (param: P) => Observable<iBXRestAnswer<T> | undefined>, param: P): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
-    abstract resultAll(): any;
-}
+import { NavvySupport, ReturnTypeNavvy } from '../NavvySupport';
+import { Observable, ReplaySubject } from 'rxjs';
+import { iBXRestAnswer } from '../../../typification/rest/base/answer';
+export declare abstract class NavvyPagNavBase<C, M, T, R, P> extends NavvySupport<C, M, T, R> {
+    protected func: (param: P) => Observable<iBXRestAnswer<T> | undefined>;
+    protected param: P;
+    protected map: ((param: T | undefined) => R | undefined) | undefined;
+    load$: ReplaySubject<number>;
+    constructor(requestClass: C, mapClass: M, func: (param: P) => Observable<iBXRestAnswer<T> | undefined>, param: P, map?: ((param: T | undefined) => R | undefined) | undefined);
+    resultVanilla(): Observable<iBXRestAnswer<T> | undefined>;
+    mapForVanilla(): ReturnTypeNavvy<Observable<iBXRestAnswer<T | undefined>>, Observable<iBXRestAnswer<R | undefined>>>;
+    protected mapForVanillaEnd(func: (param: P) => Observable<iBXRestAnswer<T> | undefined>, param: P): ReturnTypeNavvy<Observable<iBXRestAnswer<T | undefined>>, Observable<iBXRestAnswer<R | undefined>>>;
+    result(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
+    protected resultEnd(func: (param: P) => Observable<iBXRestAnswer<T> | undefined>, param: P): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
+    abstract resultAll(): any;
+}

package/services/base.d.ts

@@ -1,34 +1,22 @@
-import { DateTimeOptions } from 'luxon/src/datetime';
-import { BX_REST_SETTINGS } from '../settings';
-import * as i0 from "@angular/core";
-export declare class BaseServices {
-    BX_REST_SETTINGS: BX_REST_SETTINGS;
-    constructor(BX_REST_SETTINGS: BX_REST_SETTINGS);
-    toStr(val: any): string;
-    toNum(val: any): number;
-    toDate(val: number | string | Date, format?: string, opt?: DateTimeOptions): Date;
-    getBXStrTime(date: Date): string;
-    toISOStringWithTimezone(date: Date): string;
-    toBool(val: any): boolean;
-    toBXYorN(val: boolean): "Y" | "N";
-    typeof(val: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-    typeDefClass(val: object): undefined | null | 'date';
-    toJSON(val: object): string;
-    fromJSON<T>(val: string): T | undefined;
-    prepareBaseAddress(url: string, add?: string): string;
-    dateDiff(a: Date, b: Date): Date;
-    dateDiffInDays(a: Date, b: Date): number;
-    getBase64File(file: File): Promise<unknown>;
-    getBase64FileLikeStr(file: File): Promise<{
-        header: string;
-        val: string;
-    } | undefined>;
-    sumArray(numbers: number[]): number;
-    isItTheSameDate(date1: Date, date2: Date): boolean;
-    toUnix(date: Date): number;
-    arrSum(x: number[]): number;
-    getBaseUrlHttps(url: string, component?: boolean): string;
-    cropUrl(url: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BaseServices, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BaseServices>;
-}
+import { DateTimeOptions } from 'luxon/src/datetime';
+import * as i0 from "@angular/core";
+export declare class BaseServices {
+    toStr(val: any): string;
+    toNum(val: any): number;
+    toDate(val: number | string | Date, format?: string, opt?: DateTimeOptions): Date;
+    getBXStrTime(date: Date): string;
+    toISOStringWithTimezone(date: Date): string;
+    toBool(val: any): boolean;
+    toBXYorN(val: boolean): "Y" | "N";
+    typeof(val: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    prepareBaseAddress(url: string, add?: string | undefined): string;
+    dateDiff(a: Date, b: Date): Date;
+    dateDiffInDays(a: Date, b: Date): number;
+    getBase64File(file: File): Promise<unknown>;
+    getBase64FileLikeStr(file: File): Promise<{
+        header: string;
+        val: string;
+    } | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseServices>;
+}

package/services/http/HttpBX.d.ts

@@ -1,38 +1,37 @@
-import { Observable } from 'rxjs';
-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 declare class HttpBXServices extends HttpServices {
-    /**
-     * Это пиздец а не метод
-     * TODO: Удалить данный метод после реализации его в разделе Navvy
-     * @param param
-     */
-    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[];
-    /**
-     * Основной метод для запросов
-     *
-     * @param name
-     * @param params
-     */
-    post<T>(name: string[], params?: any): Observable<iBXRestAnswer<T> | undefined>;
-    /**
-     * Второстепенный метод для запросов. По возможности лучше не использовать
-     *
-     * @param name
-     * @param params
-     */
-    get<T>(name: string[], params?: any): Observable<iBXRestAnswer<T> | undefined>;
-    httpPost<T>(url: string, params?: any): Observable<T | undefined>;
-    httpGet<T>(url: string, params?: any): Observable<T | undefined>;
-    getNameMethod(arr: string[]): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HttpBXServices, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HttpBXServices>;
-}
+import { Observable } from 'rxjs';
+import { HttpServices } from './http';
+import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp, keyBatch } from '../../typification/rest/batch/batchRequestParam';
+import { iBXRestAnswer } from '../../typification/rest/base/answer';
+import * as i0 from "@angular/core";
+export declare class HttpBXServices extends HttpServices {
+    /**
+     * Это пиздец а не метод
+     * TODO: Удалить данный метод после реализации его в разделе Navvy
+     * @param param
+     */
+    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: keyBatch]: T;
+    };
+    mapBranchResultWithoutKey<T>(res: iBatchRequestAnswer<T>[]): T[];
+    /**
+     * Основной метод для запросов
+     *
+     * @param name
+     * @param params
+     */
+    post<T>(name: string[], params?: any): Observable<iBXRestAnswer<T> | undefined>;
+    /**
+     * Второстепенный метод для запросов. По возможности лучше не использовать
+     *
+     * @param name
+     * @param params
+     */
+    get<T>(name: string[], params?: any): Observable<iBXRestAnswer<T> | undefined>;
+    httpPost<T>(url: string, params?: any): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any): Observable<T | undefined>;
+    getNameMethod(arr: string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpBXServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpBXServices>;
+}

package/services/http/HttpData.d.ts

@@ -1,11 +1,11 @@
-import { BaseServices } from '../base';
-import { HttpParams } from '@angular/common/http';
-import { iHttpParamSettings } from '../../typification/rest/settings';
-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;
-    sliceArrayIntoChunks(arr: any[], chunkSize: number): any[][];
-    removingMultipleSlashes(str: string): string;
-}
+import { BaseServices } from '../base';
+import { HttpParams } from '@angular/common/http';
+import { iHttpParamSettings } from '../../typification/rest/settings';
+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;
+    sliceArrayIntoChunks(arr: any[], chunkSize: number): any[][];
+    removingMultipleSlashes(str: string): string;
+}

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

@@ -1,15 +1,10 @@
-import { iHttpParamSettings } from '../../../typification/rest/settings';
-import { HttpClient } from '@angular/common/http';
-import { Observable } from 'rxjs';
-import { HttpData } from '../HttpData';
-import { BX_REST_SETTINGS } from '../../../settings';
-import * as i0 from "@angular/core";
-export declare abstract class BaseHttp extends HttpData {
-    http: HttpClient;
-    protected constructor(BX_REST_SETTINGS: BX_REST_SETTINGS, http: HttpClient);
-    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>;
-}
+import { iHttpParamSettings } from '../../../typification/rest/settings';
+import { Observable } from 'rxjs';
+import { HttpData } from '../HttpData';
+import * as i0 from "@angular/core";
+export declare abstract class BaseHttp extends HttpData {
+    abstract httpGet<T>(url: string, params: any, settings: iHttpParamSettings): Observable<T | undefined>;
+    abstract httpPost<T>(url: string, params: any, settings: iHttpParamSettings): Observable<T | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseHttp>;
+}

package/services/http/http.d.ts

@@ -1,15 +1,14 @@
-import { Observable } from 'rxjs';
-import { HttpClient } from '@angular/common/http';
-import SessionKeyServices from '../../services/http/sessionKey';
-import { iHttpParamSettings } from '../../typification/rest/settings';
-import { BX_REST_SETTINGS } from '../../settings';
-import { BaseHttp } from './base/base';
-import * as i0 from "@angular/core";
-export declare class HttpServices extends BaseHttp {
-    session: SessionKeyServices;
-    constructor(BX_REST_SETTINGS: BX_REST_SETTINGS, http: HttpClient, session: SessionKeyServices);
-    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>;
-}
+import { Observable } from 'rxjs';
+import SessionKeyServices from '../../services/http/sessionKey';
+import { iHttpParamSettings } from '../../typification/rest/settings';
+import { BaseHttp } from './base/base';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class HttpServices extends BaseHttp {
+    readonly http: HttpClient;
+    readonly session: SessionKeyServices;
+    httpPost<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any): Observable<T | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpServices>;
+}

package/services/http/httpNavvy.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { iBXRestParams } from '../../typification/base/params';
+import { iBXRestAnswers } from '../../typification/base/answers';
+import { iBXRestAnswer } from '../../typification/rest/base/answer';
+import * as i0 from "@angular/core";
+export declare class HttpNavvyServices {
+    private readonly httpServices;
+    post<T extends keyof iBXRestParams>(url: [T], params?: iBXRestParams[T]): Observable<iBXRestAnswer<iBXRestAnswers[T]> | undefined>;
+    post<T extends keyof iBXRestParams, K1 extends keyof iBXRestParams>(url: [T, K1], params?: iBXRestParams[T][K1]): Observable<iBXRestAnswer<iBXRestAnswers[T][K1]> | undefined>;
+    post<T extends keyof iBXRestParams, K1 extends keyof iBXRestParams[T], K2 extends keyof iBXRestParams[T][K1]>(url: [T, K1, K2], params?: iBXRestParams[T][K1][K2]): Observable<iBXRestAnswer<iBXRestAnswers[T][K1][K2]> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpNavvyServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpNavvyServices>;
+}