bx-rest 0.9.11 → 0.10.0

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

@@ -0,0 +1,25 @@
+import { iBXRestParamTasksTaskResultList, iBXParamRestTasksTaskResultAdd, iBXRestTasksTaskResult, iBXRestTasksTaskResultHttp } from '../../../typification/rest/tasks';
+export declare class BXRestNavvyTasksTaskResult {
+    url: {
+        /**
+         *  Просмотр списка результатов к задаче
+         */
+        list: string[];
+        /**
+         * Создание результата задачи из комментария
+         */
+        addFromComment: string[];
+        /**
+         * Удаление результата задачи по комментарию из которого он был создан
+         */
+        deleteFromComment: string[];
+    };
+    private Navvy;
+    deleteFromComment(commentID: {
+        commentId: number;
+    }): import("../../../services/navvy").NavvySimple<null, null, {
+        commentId: number;
+    } | undefined>;
+    addFromComment(param: iBXParamRestTasksTaskResultAdd): import("../../../services/navvy").NavvySimple<iBXRestTasksTaskResultHttp, iBXRestTasksTaskResult, iBXParamRestTasksTaskResultAdd | undefined>;
+    list(param: iBXRestParamTasksTaskResultList): import("../../../services/navvy").NavvyPag<iBXRestTasksTaskResultHttp, iBXRestTasksTaskResult, iBXRestParamTasksTaskResultList>;
+}

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

@@ -0,0 +1,77 @@
+import { iBXRestParamTaskAdd, iBXRestParamTasksList, iBXRestTaskFieldsName, iBXRestTasksTaskBaseAnswer, iBXRestTask, iBXRestTasksTaskGetFields, iBXRestTasksTaskDeferHttp, iBXRestParamTasksTaskGet, iBXRestTasksTaskGet, iBXRestTasksTaskGetHttp, iBXRestTasksTaskGetHttpDefault, iBXRestTasksTaskFieldsCanUpdate, iBXRestParamTasksTaskApprove, iBXRestTasksTaskApproveHttp, iBXRestParamTasksTaskComplete, iBXRestTasksTaskCompleteHttp, iBXRestParamTasksTaskDefer } from '../../typification/rest/tasks';
+import { BXRestNavvyTasksTaskResult } from './task/result';
+import { iBXRestParamTaskGetAccess, iBXRestTaskGetAccess, iBXRestTaskGetAccessItem } from '../../typification/rest/task';
+import { ToUpperCaseKeys } from '../../typification/base/upper-case-keys';
+import { ObjectToSnake } from 'ts-case-convert/lib/caseConvert';
+import { AllKeyFree } from '../../typification/base/all-key-free';
+export declare class BXRestNavvyTasksTask {
+    url: {
+        /**
+         * Создает задачу
+         */
+        add: string[];
+        /**
+         * Позволяет принять задачу
+         */
+        approve: string[];
+        /**
+         * Переводит задачу в статус «завершена»
+         */
+        complete: string[];
+        /**
+         * Переводит задачу в статус «отложена»
+         */
+        defer: string[];
+        /**
+         * Метод для делегирования задачи
+         */
+        delegate: string[];
+        /**
+         * Возвращает информацию о конкретной задаче
+         */
+        get: string[];
+        /**
+         * Возвращает все доступные поля
+         */
+        getFields: string[];
+        /**
+         * Метод для проверки доступа к задаче
+         */
+        getAccess: string[];
+        /**
+         * Возвращает массив задач, каждая из которых содержит массив полей
+         */
+        list: string[];
+        /**
+         * Обновляет задачу
+         */
+        update: string[];
+        result: {
+            /**
+             *  Просмотр списка результатов к задаче
+             */
+            list: string[];
+            /**
+             * Создание результата задачи из комментария
+             */
+            addFromComment: string[];
+            /**
+             * Удаление результата задачи по комментарию из которого он был создан
+             */
+            deleteFromComment: string[];
+        };
+    };
+    readonly result: BXRestNavvyTasksTaskResult;
+    private readonly Navvy;
+    add<CustomFields extends object = object>(param: iBXRestParamTaskAdd<CustomFields>): import("../../services/navvy").NavvySimple<iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskGetHttpDefault>, iBXRestTask, iBXRestParamTaskAdd<CustomFields> | undefined>;
+    approve(param: iBXRestParamTasksTaskApprove): import("../../services/navvy").NavvySimple<iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskApproveHttp>, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskApproveHttp>, iBXRestParamTasksTaskApprove | undefined>;
+    complete(param: iBXRestParamTasksTaskComplete): import("../../services/navvy").NavvySimple<iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskCompleteHttp>, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskCompleteHttp>, iBXRestParamTasksTaskComplete | undefined>;
+    defer(param: iBXRestParamTasksTaskDefer): import("../../services/navvy").NavvySimple<iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>, iBXRestParamTasksTaskDefer | undefined>;
+    update<CustomFields extends object>(task: AllKeyFree<iBXRestTasksTaskGet<iBXRestTaskFieldsName[], CustomFields>>, updateFields: (iBXRestTasksTaskFieldsCanUpdate | keyof ToUpperCaseKeys<ObjectToSnake<CustomFields>>)[]): import("../../services/navvy").NavvySimple<iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>, any>;
+    get<S extends iBXRestTaskFieldsName[], CustomFields extends object = object>(param: iBXRestParamTasksTaskGet<CustomFields>): import("../../services/navvy").NavvySimple<iBXRestTasksTaskGetHttp<S, CustomFields>, iBXRestTasksTaskGet<S, CustomFields>, iBXRestParamTasksTaskGet<CustomFields> | undefined>;
+    list<S extends iBXRestTaskFieldsName[], CustomFields extends object = object>(param?: iBXRestParamTasksList<CustomFields>): import("../../services/navvy").NavvyPagNavTasks<import("../../typification/rest/tasks").iBXRestHttpTasksTaskList<S, CustomFields>, import("../../typification/rest/tasks").iBXRestTasksTaskList<S, CustomFields>, iBXRestParamTasksList<CustomFields>>;
+    getFields(): import("../../services/navvy").NavvySimple<iBXRestTasksTaskGetFields, iBXRestTasksTaskGetFields, undefined>;
+    getAccess(param: iBXRestParamTaskGetAccess): import("../../services/navvy").NavvySimple<iBXRestTaskGetAccess, {
+        [key: number]: iBXRestTaskGetAccessItem;
+    }, iBXRestParamTaskGetAccess | undefined>;
+}

package/request-navvy/tasks.d.ts

@@ -0,0 +1,4 @@
+import { BXRestNavvyTasksTask } from './tasks/task';
+export declare class BXRestNavvyTasks {
+    readonly task: BXRestNavvyTasksTask;
+}

package/request-navvy/timeman.d.ts

@@ -0,0 +1,32 @@
+import { iBXRestParamTimeManClose, iBXRestParamTimeManOpen, iBXRestParamTimeManPause, iBXRestParamTimeManSettings, iBXRestParamTimeManStatus, iBXRestTimeManSettings, iBXRestTimeManStatus, iBXRestTimeManStatusHttp } from '../typification/rest/timeman';
+import { Navvy } from '../services/navvy';
+export declare class BXRestNavvyTimeMan {
+    protected readonly url: {
+        /**
+         * Получение настроек рабочего времени пользователя
+         */
+        settings: string[];
+        /**
+         * Получение информации о текущем рабочем дне пользователя
+         */
+        status: string[];
+        /**
+         * Начать новый рабочий день либо возобновить закрытый или приостановленный
+         */
+        open: string[];
+        /**
+         * Закрыть рабочий день
+         */
+        close: string[];
+        /**
+         * Приостановить рабочий день
+         */
+        pause: string[];
+    };
+    protected Navvy: Navvy;
+    status(param?: iBXRestParamTimeManStatus | undefined): import("../services/navvy").NavvySimple<iBXRestTimeManStatusHttp, iBXRestTimeManStatus, iBXRestParamTimeManStatus | undefined>;
+    open(param?: iBXRestParamTimeManOpen): import("../services/navvy").NavvySimple<iBXRestTimeManStatusHttp, iBXRestTimeManStatus, iBXRestParamTimeManOpen | undefined>;
+    pause(param?: iBXRestParamTimeManPause): import("../services/navvy").NavvySimple<iBXRestTimeManStatusHttp, iBXRestTimeManStatus, iBXRestParamTimeManPause | undefined>;
+    close(param?: iBXRestParamTimeManClose): import("../services/navvy").NavvySimple<iBXRestTimeManStatusHttp, iBXRestTimeManStatus, iBXRestParamTimeManClose | undefined>;
+    settings(param?: iBXRestParamTimeManSettings): import("../services/navvy").NavvySimple<iBXRestTimeManSettings, iBXRestTimeManSettings, iBXRestParamTimeManSettings | undefined>;
+}

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

@@ -0,0 +1,6 @@
+import { iBXRestUserUserField } from '../../typification/rest/user';
+export declare class BXRestNavvyUserUserfield {
+    private url;
+    private readonly Navvy;
+    list(): import("../../services/navvy").NavvySimple<iBXRestUserUserField[], iBXRestUserUserField[], undefined>;
+}

package/request-navvy/user.d.ts

@@ -0,0 +1,28 @@
+import { iBXRestParamUserGet, iBXRestParamUserSearch, iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '../typification/rest/user';
+import { BXRestNavvyUserUserfield } from './user/userfield';
+export declare class BXRestNavvyUser {
+    def: {
+        params: {
+            ACTIVE: boolean;
+            start: 0;
+        };
+    };
+    url: {
+        admin: string[];
+        get: string[];
+        current: string[];
+        update: string[];
+        search: string[];
+        access: string[];
+        fields: string[];
+    };
+    readonly userField: BXRestNavvyUserUserfield;
+    private readonly Navvy;
+    admin(): import("../services/navvy").NavvySimple<boolean, boolean, undefined>;
+    get(params?: iBXRestParamUserGet): import("../services/navvy").NavvyPag<iBXRestUserHttp, iBXRestUser, iBXRestParamUserGet>;
+    current(): import("../services/navvy").NavvySimple<iBXRestUserHttp, iBXRestUser, undefined>;
+    search(params: iBXRestParamUserSearch): import("../services/navvy").NavvyPag<iBXRestUserHttp, iBXRestUser, iBXRestParamUserSearch>;
+    access(params: string[]): import("../services/navvy").NavvySimple<boolean, boolean, string[] | undefined>;
+    fields(): import("../services/navvy").NavvySimple<iBXRestUserHttpField, iBXRestUserHttpField, undefined>;
+    private setDefParam;
+}

package/rest/base.d.ts

@@ -0,0 +1,33 @@
+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 { BXRestSonetGroup } from '../request/sonet_group';
+import { BXRestServer } from '../request/server';
+import { BXRestDepartment } from '../request/department';
+import { BXRestApp } from '../request/app';
+import { iBXRestProfileHttp } from '../typification/rest/profile';
+import { iBXRestBatch, iBXRestParamBatch } from '../typification/rest/batch';
+import { BXRestSocialNetWork } from '../request/socialnetwork';
+import { BXRestPull } from '../request/pull';
+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 sonet_group: BXRestSonetGroup;
+    readonly server: BXRestServer;
+    readonly department: BXRestDepartment;
+    readonly app: BXRestApp;
+    readonly socialNetWork: BXRestSocialNetWork;
+    readonly pull: BXRestPull;
+    profile(): import("rxjs").Observable<import("../typification/rest/base").iBXRestAnswer<iBXRestProfileHttp> | undefined>;
+    batch<T>(param: iBXRestParamBatch): import("rxjs").Observable<import("../typification/rest/base").iBXRestAnswer<iBXRestBatch<T>> | undefined>;
+}

package/rest/map.d.ts

@@ -0,0 +1,20 @@
+import { BXRestMapLists } from '../map/lists';
+import { BXRestMapUser } from '../map/user';
+import { BXRestMapSonetGroup } from '../map/sonet_group';
+import { BXRestMapServer } from '../map/server';
+import { BXRestDisk } from '../request/disk';
+import { BXRestMapCalendar } from '../map/calendar';
+import { BXRestMapLog } from '../map/log';
+import { BXRestMapTask } from '../map/task';
+import { BXRestMapTasks } from '../map/tasks';
+export declare class BXRestMap {
+    get user(): typeof BXRestMapUser;
+    get sonet_group(): typeof BXRestMapSonetGroup;
+    get server(): typeof BXRestMapServer;
+    get lists(): typeof BXRestMapLists;
+    get disk(): typeof BXRestDisk;
+    get calendar(): typeof BXRestMapCalendar;
+    get log(): typeof BXRestMapLog;
+    get task(): typeof BXRestMapTask;
+    get tasks(): typeof BXRestMapTasks;
+}

package/rest/navvy.d.ts

@@ -0,0 +1,40 @@
+import { Navvy } from '../services/navvy';
+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 { BXRestNavvySocialNetWork } from '../request-navvy/socialnetwork';
+import { BXRestNavvyPull } from '../request-navvy/pull';
+import { BXRestNavvyCrm } from '../request-navvy/crm';
+import { iBXRestProfile, iBXRestProfileHttp } from '../typification/rest/profile';
+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;
+    readonly socialNetWork: BXRestNavvySocialNetWork;
+    readonly pull: BXRestNavvyPull;
+    readonly crm: BXRestNavvyCrm;
+    readonly Navvy: Navvy;
+    profile(): import("../services/navvy").NavvySimple<iBXRestProfileHttp, iBXRestProfile, undefined>;
+}

package/services/base.d.ts

@@ -0,0 +1,67 @@
+import { DateTimeOptions } from 'luxon';
+/**
+ * Преобразует значение в строку
+ *
+ * @param val
+ * @param throwError
+ */
+export declare function toStr(val: any, throwError?: boolean): string;
+/**
+ * Преобразует значение в число
+ */
+export declare function toNum(val: any, throwError?: boolean, defValue?: number): number;
+/**
+ * Кастомный тип ошибки для числовых преобразований
+ */
+export declare class ToNumError extends Error {
+    readonly value: any;
+    constructor(value: any);
+    toString(): string;
+}
+/**
+ * Преобразует значение в дату
+ */
+export declare function toDate(val: number | string | Date, format?: string, opt?: DateTimeOptions, throwError?: boolean): Date;
+/**
+ * Преобразует дату в строку с учетом временной зоны
+ *
+ * @param date
+ * @param throwError
+ */
+export declare function toISOStringWithTimezone(date: Date, throwError?: boolean): string;
+/**
+ * Преобразует значение в булево значение
+ *
+ * @param val
+ * @param throwError
+ */
+export declare function toBool(val: any, throwError?: boolean): boolean;
+/**
+ * Преобразует булево значение в 'Y' или 'N'
+ *
+ * @param val
+ */
+export declare function toBXYorN(val: boolean): string;
+export declare function getBaseUrlHttps(url: string, component?: boolean): string;
+/**
+ * Обрезает URL (удаляет протокол)
+ *
+ * @param url
+ */
+export declare function cropUrl(url: string): string;
+/**
+ * Преобразует файл в base64
+ *
+ * @param file
+ */
+export declare function getBase64File(file: File): Promise<string>;
+/**
+ * Получить файл в формате base64 с разбивкой на заголовок и данные
+ *
+ * @param file
+ */
+export declare function getBase64FileLikeStr(file: File): Promise<{
+    header: string;
+    val: string;
+} | undefined>;
+export declare function prepareBaseAddress(url: string, add?: string | undefined): string;

package/services/http/HttpBX.d.ts

@@ -0,0 +1,33 @@
+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';
+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>[]): Record<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>;
+    serializeBitrixParams(params: unknown): string;
+    httpGet<T>(url: string, params?: any): Observable<T | undefined>;
+    getNameMethod(arr: string[]): string;
+}

package/services/http/HttpData.d.ts

@@ -0,0 +1,7 @@
+import { iHttpParamSettings } from '../../typification/rest/settings';
+export declare class HttpData {
+    defSettings: iHttpParamSettings;
+    getHttpParamsPost(obj: any, sendHttpParams?: FormData, nesting?: string[], settings?: iHttpParamSettings): any;
+    sliceArrayIntoChunks(arr: any[], chunkSize: number): any[][];
+    removingMultipleSlashes(str: string): string;
+}

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

@@ -0,0 +1,7 @@
+import { iHttpParamSettings } from '../../../typification/rest/settings';
+import { Observable } from 'rxjs';
+import { HttpData } from '../HttpData';
+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>;
+}

package/services/http/http.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { AxiosInstance } from 'axios';
+import { SessionKeyServices } from '../../services/http/sessionKey';
+import { iHttpParamSettings } from '../../typification/rest/settings';
+import { BaseHttp } from './base/base';
+export declare class HttpServices extends BaseHttp {
+    protected readonly axiosInstance: AxiosInstance;
+    readonly session: SessionKeyServices;
+    constructor();
+    httpPost<T>(url: string, params?: any, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any): Observable<T | undefined>;
+}

package/services/http/httpNavvy.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { iBXRestParams } from '../../typification/base/params';
+import { iBXRestAnswer } from '../../typification/rest/base';
+import { iBXRestAnswers } from '../../typification/base/answers';
+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>;
+}

package/services/http/sessionKey.d.ts

@@ -0,0 +1,34 @@
+import { Observable, Subscription } from 'rxjs';
+import { iBXRestAuth } from '../../typification/auth/save';
+type IKeyAuth = 'sessid' | 'auth' | string;
+export declare class SessionKeyError extends Error {
+    constructor(message: string);
+}
+export declare class SessionKeyServices {
+    authHave: boolean;
+    authData: iBXRestAuth | undefined;
+    subscribe: {
+        authData: Subscription;
+    };
+    private readonly BX_REST_SETTINGS;
+    constructor();
+    subscribeAll(): void;
+    getAuth(): string;
+    getKeyAuth(): IKeyAuth;
+    getSessid(): string;
+    getAuthParams(): string | undefined;
+    getCheckAuthParamsIsOn(): boolean;
+    getAuthError(operation?: string): SessionKeyError;
+    getBaseUrl(): Observable<string | undefined>;
+    getBaseUrlError(operation?: string): SessionKeyError;
+    private getAuthCheckedPlaces;
+    private getBxSessid;
+    private getSearchParam;
+    private getCookie;
+    private getLocalStorage;
+    private setLocalStorage;
+    private getSessionItem;
+    private getStorageItem;
+    private normalizeValue;
+}
+export {};

package/services/navvy/extends/navvy-pag-base.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { iBXRestAnswer } from '../../../typification/rest/base/answer';
+import { HttpBXServices } from '../../http/HttpBX';
+import { ReturnTypeNavvy } from '../navvy-support';
+export declare abstract class NavvyPagBase<T, R, P> {
+    protected url: string[];
+    protected param: P;
+    protected map: ((param: T | undefined) => R | undefined) | undefined;
+    protected readonly http: HttpBXServices;
+    pageSize: number;
+    constructor(url: string[], param: P, map?: ((param: T | undefined) => R | undefined) | undefined);
+    resVanilla(): Observable<iBXRestAnswer<T> | undefined>;
+    mapForVanilla(): Observable<iBXRestAnswer<ReturnTypeNavvy<T, R>> | undefined>;
+    res(): Observable<ReturnTypeNavvy<T, R> | undefined>;
+    mapAndError<T>(request: Observable<iBXRestAnswer<T> | undefined>): Observable<T | undefined>;
+}

package/services/navvy/navvy-alternative-pagination-navigation.d.ts

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

package/services/navvy/navvy-pag-nav-result-key.d.ts

@@ -0,0 +1,13 @@
+import { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx';
+import { ReturnTypeNavvy } from './navvy-support';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+type KeyedResult<K extends string, T> = Record<K, T[] | undefined>;
+export declare class NavvyPagNavResultKey<T, R, P extends iBXRestPagination, K extends string> extends NavvyPagBase<KeyedResult<K, T>, R[], P> {
+    private readonly key;
+    save: ReturnTypeNavvy<T, R>[];
+    constructor(url: string[], param: P, key: K, map?: (param: KeyedResult<K, T> | undefined) => R[] | undefined);
+    resAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
+    private resultAllEnd;
+    private mapResForGetAll;
+}
+export {};

package/services/navvy/navvy-pag-nav-tasks.d.ts

@@ -0,0 +1,11 @@
+import { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx';
+import { ReturnTypeNavvy } from './navvy-support';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+export declare class NavvyPagNavTasks<T, R, P extends iBXRestPagination> extends NavvyPagBase<{
+    tasks: T[] | undefined;
+}, R[], P> {
+    save: ReturnTypeNavvy<T, R>[];
+    resAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
+    private resultAllEnd;
+    private mapResForGetAll;
+}

package/services/navvy/navvy-pag-nav-with-useless-key.d.ts

@@ -0,0 +1,7 @@
+import { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+import { ReturnTypeNavvy } from './navvy-support';
+export declare class NavvyPagNavWithUselessKey<T, R, P extends iBXRestPagination> extends NavvyPagBase<Record<string, T>, R[], P> {
+    save: ReturnTypeNavvy<Record<string, T>, R[]>;
+    resAll(): import("rxjs").Observable<R[] | undefined>;
+}

package/services/navvy/navvy-pag.d.ts

@@ -0,0 +1,8 @@
+import { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx';
+import { ReturnTypeNavvy } from './navvy-support';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+export declare class NavvyPag<T, R, P extends iBXRestPagination> extends NavvyPagBase<T[], R[], P> {
+    save: ReturnTypeNavvy<T, R>[];
+    resAll(): import("rxjs").Observable<ReturnTypeNavvy<T, R>[]>;
+    private mapResForGetAll;
+}

package/services/navvy/navvy-simple.d.ts

@@ -0,0 +1,3 @@
+import { NavvyPagBase } from './extends/navvy-pag-base';
+export declare class NavvySimple<T, R, P> extends NavvyPagBase<T, R, P> {
+}

package/services/navvy/navvy-support.d.ts

@@ -0,0 +1,11 @@
+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, T, R> {
+    requestClass: C;
+    pageSize: number;
+    protected constructor(requestClass: C);
+    mapAndError<T>(request: Observable<iBXRestAnswer<T> | undefined>): Observable<T | undefined>;
+    abstract resVanilla(): Observable<iBXRestAnswer<T> | undefined>;
+    abstract res(): ReturnTypeNavvy<Observable<T | undefined>, Observable<R | undefined>>;
+}

package/services/navvy.d.ts

@@ -0,0 +1,32 @@
+import { NavvySimple } from './navvy/navvy-simple';
+import { NavvyAlterPagNav } from './navvy/navvy-alternative-pagination-navigation';
+import { iBXRestAlternativePagination, iBXRestPagination } from '../typification/rest/base/api-pagination-bx';
+import { NavvyPagNavWithUselessKey } from './navvy/navvy-pag-nav-with-useless-key';
+import { NavvyPagNavTasks } from './navvy/navvy-pag-nav-tasks';
+import { NavvyPag } from './navvy/navvy-pag';
+import { NavvyPagNavResultKey } from './navvy/navvy-pag-nav-result-key';
+export * from './navvy/navvy-simple';
+export * from './navvy/navvy-alternative-pagination-navigation';
+export * from './navvy/navvy-pag-nav-with-useless-key';
+export * from './navvy/navvy-pag-nav-tasks';
+export * from './navvy/navvy-pag-nav-result-key';
+export * from './navvy/navvy-pag';
+export * from './navvy/navvy-support';
+export declare class Navvy {
+    simple<T, R = T, A = undefined>(url: string[], arg?: A, map?: (param: T | undefined) => R | undefined): NavvySimple<T, R, (A & ({} | null)) | undefined>;
+    /**
+     * Новый, пока тестируемый метод для api методов с пагинацией
+     *
+     * @param url
+     * @param arg
+     * @param map
+     * @constructor
+     */
+    pagNav<T, R, A extends iBXRestPagination>(url: string[], arg: A, map?: (param: T[] | undefined) => R[] | undefined): NavvyPag<T, R, A>;
+    pagNavTasks<T, R, A extends iBXRestPagination>(url: string[], arg: A, map?: (param: {
+        tasks: T[] | undefined;
+    } | undefined) => R[] | undefined): NavvyPagNavTasks<T, R, A>;
+    pagNavResultKey<T, R, A extends iBXRestPagination, K extends string>(url: string[], arg: A, key: K, map?: (param: Record<K, T[] | undefined> | undefined) => R[] | undefined): NavvyPagNavResultKey<T, R, A, K>;
+    pagNavWithUselessKey<T, R, A extends iBXRestPagination>(url: string[], arg: A, map?: (param: Record<string, T> | undefined) => R[] | undefined): NavvyPagNavWithUselessKey<T, R, A>;
+    alterPagNav<T, R, A extends iBXRestAlternativePagination>(url: string[], arg: A, map?: (param: T[] | undefined) => R[] | undefined): NavvyAlterPagNav<T, R, A>;
+}

package/services/vanilla/localStorage.d.ts

@@ -0,0 +1,7 @@
+export declare class LocalStorageServices {
+    static get(name: string): any;
+    static getObj<T>(name: string): T | null;
+    static set(name: string, value: string): void;
+    static setObj(name: string, value: any): void;
+    static del(name: string): void;
+}

package/services/vanilla/sessionStorage.d.ts

@@ -0,0 +1,4 @@
+export declare class SessionStorage {
+    static setItem(name: string, value: any): void;
+    static getItem<T>(name: string): T | undefined;
+}

package/services/vanilla//321/201ookies.d.ts

@@ -0,0 +1,6 @@
+export default class CookiesServices {
+    static get(name: string): string;
+    static set(name: string, value: string, age?: number): void;
+    static setObj(name: string, value: any, age?: number): void;
+    static getObj<T>(name: string): T | false;
+}

package/settings.d.ts

@@ -0,0 +1,6 @@
+import { iBXRestSettings } from './typification/settings';
+export declare const DEFAULT_BX_REST_SETTINGS: iBXRestSettings;
+export declare const BXRestSettings: {
+    date: iBXRestSettings;
+    update(newSettings: Partial<iBXRestSettings>): void;
+};

package/typification/auth/save.d.ts

@@ -0,0 +1,14 @@
+export interface iBXRestAuth {
+    access_token: string;
+    client_endpoint: string;
+    domain: string;
+    expires: number;
+    expires_in: number;
+    member_id: string;
+    refresh_token: string;
+    scope: string;
+    server_endpoint: string;
+    status: string;
+    user_id: number;
+    state?: any;
+}