bx-rest 0.26.0 → 0.26.1

package/rest/navvy.d.ts

@@ -0,0 +1,114 @@
+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 { BXRestNavvyEvent } from '../request-navvy/event';
+import { iBXRestProfile, iBXRestProfileHttp } from '../typification/rest/profile';
+import { BXRestNavvyMethod } from '../request-navvy/method';
+import { BXRestNavvyAccess } from '../request-navvy/access';
+import { BXRestNavvyFeature } from '../request-navvy/feature';
+import { BXRestNavvyAi } from '../request-navvy/ai/index';
+import { BXRestNavvyMailService } from '../request-navvy/mailservice';
+import { BXRestNavvyMessageService } from '../request-navvy/messageservice/index';
+import { BXRestNavvyUserConsent } from '../request-navvy/userconsent/index';
+import { BXRestNavvyTelephony } from '../request-navvy/telephony/index';
+import { BXRestNavvyVote } from '../request-navvy/vote/index';
+import { BXRestNavvyImConnector } from '../request-navvy/imconnector/index';
+import { BXRestNavvyEntity } from '../request-navvy/entity/index';
+import { BXRestNavvyBiConnector } from '../request-navvy/biconnector/index';
+import { BXRestNavvyVoxImplant } from '../request-navvy/voximplant/index';
+import { BXRestNavvyMail } from '../request-navvy/mail/index';
+import { BXRestNavvyNote } from '../request-navvy/note/index';
+import { BXRestNavvyDocumentGenerator } from '../request-navvy/documentgenerator/index';
+import { BXRestNavvyImBot } from '../request-navvy/imbot/index';
+import { BXRestNavvyBooking } from '../request-navvy/booking/index';
+import { BXRestNavvyImOpenLines } from '../request-navvy/imopenlines/index';
+import { BXRestNavvyLanding } from '../request-navvy/landing/index';
+import { BXRestNavvyCatalog } from '../request-navvy/catalog/index';
+import { BXRestNavvySale } from '../request-navvy/sale/index';
+import { BXRestNavvySign } from '../request-navvy/sign/index';
+import { BXRestNavvyEventLog } from '../request-navvy/eventlog/index';
+import { BXRestNavvyPlacement } from '../request-navvy/placement';
+import { BXRestNavvyUserFieldType } from '../request-navvy/userfieldtype';
+import { iBXRestParamScope } from '../typification/rest/common';
+export declare class BXRestNavvy {
+    readonly ai: BXRestNavvyAi;
+    readonly mailService: BXRestNavvyMailService;
+    readonly messageService: BXRestNavvyMessageService;
+    readonly userConsent: BXRestNavvyUserConsent;
+    readonly telephony: BXRestNavvyTelephony;
+    readonly vote: BXRestNavvyVote;
+    readonly imConnector: BXRestNavvyImConnector;
+    readonly entity: BXRestNavvyEntity;
+    readonly biConnector: BXRestNavvyBiConnector;
+    readonly voxImplant: BXRestNavvyVoxImplant;
+    readonly mail: BXRestNavvyMail;
+    readonly note: BXRestNavvyNote;
+    readonly documentGenerator: BXRestNavvyDocumentGenerator;
+    readonly imBot: BXRestNavvyImBot;
+    readonly booking: BXRestNavvyBooking;
+    readonly imOpenLines: BXRestNavvyImOpenLines;
+    readonly landing: BXRestNavvyLanding;
+    readonly catalog: BXRestNavvyCatalog;
+    readonly sale: BXRestNavvySale;
+    readonly sign: BXRestNavvySign;
+    readonly eventLog: BXRestNavvyEventLog;
+    readonly placement: BXRestNavvyPlacement;
+    readonly userFieldType: BXRestNavvyUserFieldType;
+    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 event: BXRestNavvyEvent;
+    /** Проверка существования и доступности REST-методов. */
+    readonly method: BXRestNavvyMethod;
+    /** Получение описаний кодов доступа. */
+    readonly access: BXRestNavvyAccess;
+    /** Проверка доступности возможностей портала. */
+    readonly feature: BXRestNavvyFeature;
+    readonly Navvy: Navvy;
+    /**
+     * Возвращает базовую информацию о текущем пользователе без scope `user`.
+     *
+     * Результат содержит идентификатор, имя, фамилию, признак администратора,
+     * пол, часовой пояс и связанные поля профиля.
+     */
+    profile(): import("../services/navvy").NavvySimple<iBXRestProfileHttp, iBXRestProfile, undefined>;
+    /**
+     * Возвращает разрешения текущего приложения.
+     *
+     * Передайте `{ full: true }`, чтобы запросить полный список разрешений
+     * портала. Без параметров возвращаются разрешения, доступные приложению.
+     */
+    scope(param?: iBXRestParamScope): import("../services/navvy").NavvySimple<string[], string[], iBXRestParamScope | undefined>;
+    /** Возвращает список REST-методов, доступных текущему приложению. */
+    methods(): import("../services/navvy").NavvySimple<string[], string[], undefined>;
+}

package/services/base.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Преобразует значение в строку
+ *
+ * @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;
+}
+/**
+ * Опции для toDate(). Оставлены для обратной совместимости сигнатуры — ранее пробрасывались
+ * в luxon (зона/локаль). Разбор даты теперь не зависит от внешних библиотек и поддерживает
+ * только фиксированные числовые токены (см. parseDateWithFormat), поэтому опции сейчас не используются.
+ */
+export interface ToDateOptions {
+    zone?: string;
+    locale?: string;
+}
+/**
+ * Выводит формат "только дата" из формата даты-и-времени — отрезает время и разделитель перед
+ * ним (например, `'dd.MM.yyyy HH:mm:ss'` → `'dd.MM.yyyy'`). Порядок день/месяц/год у полей
+ * "дата" и "дата-время" на одном портале Bitrix24 всегда согласован — различается только
+ * наличие `HH:mm:ss`, поэтому нет смысла заставлять вызывающего передавать оба формата и
+ * держать их в синхроне вручную.
+ */
+export declare function deriveDateOnlyFormat(dateTimeFormat: string): string;
+/**
+ * Преобразует значение в дату.
+ *
+ * Если передан `format`, но значение ему не соответствует (см. FALLBACK_DATE_FORMATS —
+ * актуально для полей, где Bitrix24 отдаёт дату в формате, настроенном на портале, а не в
+ * том, что захардкожен в маппере), перед тем как считать значение невалидным, делаются ещё
+ * две попытки: другие распространённые форматы Bitrix24, а затем — позиционная эвристика
+ * (см. parseDateHeuristically), которая распознаёт практически любой чисто числовой формат
+ * даты независимо от разделителя. Если приложению точно известен формат конкретного портала,
+ * его стоит передавать явным `format` — это всегда приоритетнее угадывания.
+ */
+export declare function toDate(val: number | string | Date, format?: string, opt?: ToDateOptions, throwError?: boolean): Date;
+/**
+ * Преобразует дату в строку с учетом временной зоны
+ *
+ * Форматирование делегировано toLocalAtom() — раньше здесь была вторая,
+ * независимая копия той же формулы (paddind + смещение таймзоны), которая
+ * могла разойтись с toLocalAtom() при правке одной из них и не другой.
+ *
+ * @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,32 @@
+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, restApi?: boolean): 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;
+    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,28 @@
+import { Observable } from 'rxjs';
+import { iBXRestAnswer } from '../../../typification/rest/base/answer';
+import { HttpBXServices } from '../../http/HttpBX';
+import { ReturnTypeNavvy } from '../navvy-support';
+export interface BXRestResOptions {
+    /**
+     * When `true`, a Bitrix-level API error (`{ error, error_description }`,
+     * e.g. `INSUFFICIENT_SCOPE`, `expired_token`) makes the `Observable`
+     * returned by `.res()` error out with a `BXRestApiError` instead of
+     * resolving with `undefined`.
+     *
+     * Default: `false` (preserves the historical `.res()` behaviour).
+     */
+    throwOnApiError?: boolean;
+}
+export declare abstract class NavvyPagBase<T, R, P> {
+    protected url: string[];
+    protected param: P;
+    protected map: ((param: T | undefined) => R | undefined) | undefined;
+    protected restApi: boolean;
+    protected readonly http: HttpBXServices;
+    pageSize: number;
+    constructor(url: string[], param: P, map?: ((param: T | undefined) => R | undefined) | undefined, restApi?: boolean);
+    resVanilla(): Observable<iBXRestAnswer<T> | undefined>;
+    mapForVanilla(): Observable<iBXRestAnswer<ReturnTypeNavvy<T, R>> | undefined>;
+    res(options?: BXRestResOptions): Observable<ReturnTypeNavvy<T, R> | undefined>;
+    mapAndError<T>(request: Observable<iBXRestAnswer<T> | undefined>, options?: BXRestResOptions): 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-object.d.ts

@@ -0,0 +1,12 @@
+import { iBXRestPagination } from '../../typification/rest/base/api-pagination-bx';
+import { NavvyPagBase } from './extends/navvy-pag-base';
+type KeyedObjectResult<K extends string, T> = Record<K, Record<string, T> | undefined>;
+/** Пагинация для методов, возвращающих коллекцию как объект с идентификаторами в ключах. */
+export declare class NavvyPagNavResultKeyObject<T, R, P extends iBXRestPagination, K extends string> extends NavvyPagBase<KeyedObjectResult<K, T>, R[], P> {
+    private readonly key;
+    constructor(url: string[], param: P, key: K, mapResult?: (param: KeyedObjectResult<K, T> | undefined) => R[] | undefined);
+    resAll(): import("rxjs").Observable<R[] | undefined>;
+    private resultAllEnd;
+    private mapResult;
+}
+export {};

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,36 @@
+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';
+import { NavvyPagNavResultKeyObject } from './navvy/navvy-pag-nav-result-key-object';
+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-pag-nav-result-key-object';
+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>;
+    simpleV3<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>;
+    pagNavResultKeyObject<T, R, A extends iBXRestPagination, K extends string>(url: string[], arg: A, key: K, map?: (param: Record<K, Record<string, T> | undefined> | undefined) => R[] | undefined): NavvyPagNavResultKeyObject<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/cookies.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/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/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;
+}

package/typification/base/all-key-free.d.ts

@@ -0,0 +1,3 @@
+export type AllKeyFree<T> = {
+    [K in keyof T as K & string]?: T[K];
+};

package/typification/base/answers.d.ts

@@ -0,0 +1,12 @@
+import { iBXRestTasksTaskBaseAnswer } from '../rest/tasks/task/base';
+import { iBXRestTasksTaskGetHttpDefault } from '../rest/tasks/task/get';
+import { iBXRestTasksTaskApproveHttp } from '../rest/tasks/task/approve';
+import { iBXRestTasksTaskCompleteHttp } from '../rest/tasks/task/complete';
+import { iBXRestTasksTaskDeferHttp } from '../rest/tasks/task/defer';
+import { iBXRestTaskGetAccess } from '../rest/task/access/getaccess';
+import { iBXRestTasksTaskResultHttp } from '../rest/tasks/task/result/result';
+import { iBXRestUserHttp, iBXRestUserHttpField } from '../rest/user/user';
+import { iBXRestWorkpieceMethodsFull } from './workpiece/methods';
+import { iBXRestWorkpieceMethodsTasks, iBXRestWorkpieceMethodsTasksTask, iBXRestWorkpieceMethodsTasksTaskResult, iBXRestWorkpieceMethodsUser, iBXRestWorkpieceMethodsUserField, iBXRestWorkpieceMethodsUserFieldList } from './workpiece/methods-list';
+export interface iBXRestAnswers extends iBXRestWorkpieceMethodsFull<iBXRestWorkpieceMethodsUser<boolean, iBXRestUserHttp[], iBXRestUserHttp, iBXRestUserHttp[], iBXRestUserHttp[], boolean, iBXRestUserHttpField, iBXRestWorkpieceMethodsUserField<any, any, any, any, iBXRestWorkpieceMethodsUserFieldList<any>>>, iBXRestWorkpieceMethodsTasks<iBXRestWorkpieceMethodsTasksTask<any, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskApproveHttp>, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskCompleteHttp>, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskGetHttpDefault>, any, any, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>, iBXRestTaskGetAccess, any, any, iBXRestWorkpieceMethodsTasksTaskResult<iBXRestTasksTaskResultHttp[], iBXRestTasksTaskResultHttp, any>>>, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}

package/typification/base/modyfy.d.ts

@@ -0,0 +1,9 @@
+export type Modify<T, R> = Omit<T, keyof R> & R;
+export type ModifyDeep<A, B extends DeepPartialAny<A>> = {
+    [K in keyof A | keyof B]: K extends keyof A ? K extends keyof B ? A[K] extends AnyObject ? B[K] extends AnyObject ? ModifyDeep<A[K], B[K]> : B[K] : B[K] : A[K] : B[K];
+};
+type AnyObject = Record<string, any>;
+type DeepPartialAny<T> = {
+    [P in keyof T]?: T[P] extends AnyObject ? DeepPartialAny<T[P]> : any;
+};
+export {};

package/typification/base/params.d.ts

@@ -0,0 +1,16 @@
+import { iBXRestUser } from '../rest/user/user';
+import { iBXRestParamUserSearch } from '../rest/user/search';
+import { iBXRestParamTasksTaskApprove } from '../rest/tasks/task/approve';
+import { iBXRestParamTasksTaskComplete } from '../rest/tasks/task/complete';
+import { iBXRestParamTasksTaskDefer, iBXRestTasksTaskDeferHttp } from '../rest/tasks/task/defer';
+import { iBXRestParamTasksTaskUpdate } from '../rest/tasks/task/update';
+import { iBXRestTaskGetAccess } from '../rest/task/access/getaccess';
+import { iBXRestParamTasksTaskResultList } from '../rest/tasks/result/list';
+import { iBXParamRestTasksTaskResultAdd } from '../rest/tasks/task/result/result';
+import { iBXRestParamTaskAdd } from '../rest/tasks/task/add';
+import { iBXRestWorkpieceMethodsFull } from './workpiece/methods';
+import { iBXRestWorkpieceMethodsTasks, iBXRestWorkpieceMethodsTasksTask, iBXRestWorkpieceMethodsTasksTaskResult, iBXRestWorkpieceMethodsUser, iBXRestWorkpieceMethodsUserField, iBXRestWorkpieceMethodsUserFieldList } from './workpiece/methods-list';
+import { iBXRestTasksTaskBaseAnswer } from '../rest/tasks/task/base';
+import { iBXRestParamUserGet } from '../rest/user/get';
+export interface iBXRestParams extends iBXRestWorkpieceMethodsFull<iBXRestWorkpieceMethodsUser<undefined, iBXRestParamUserGet, undefined, Partial<iBXRestUser>, iBXRestParamUserSearch, string[], undefined, iBXRestWorkpieceMethodsUserField<any, any, any, any, iBXRestWorkpieceMethodsUserFieldList<any>>>, iBXRestWorkpieceMethodsTasks<iBXRestWorkpieceMethodsTasksTask<iBXRestParamTaskAdd<any>, iBXRestParamTasksTaskApprove, iBXRestParamTasksTaskComplete, iBXRestParamTasksTaskDefer, iBXRestParamTasksTaskUpdate, any, iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>, iBXRestTaskGetAccess, any, any, iBXRestWorkpieceMethodsTasksTaskResult<iBXRestParamTasksTaskResultList, iBXParamRestTasksTaskResultAdd, any>>>, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}

package/typification/base/upper-case-keys.d.ts

@@ -0,0 +1,6 @@
+export type ToUpperCaseKeys<T> = {
+    [K in keyof T as Uppercase<K & string>]: T[K];
+};
+export type ToUpperCaseFreeKeys<T> = {
+    [K in keyof T as Uppercase<K & string>]?: T[K];
+};