bx-rest 0.10.5 → 0.10.6

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-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,35 @@
+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>;
+    /**
+     * Новый, пока тестируемый метод для 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/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;
+}

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];
+};

package/typification/base/workpiece/methods-list.d.ts

@@ -0,0 +1,247 @@
+export interface iBXRestWorkpieceMethodsUser<admin, _get, current, update, search, access, fields, userfield> {
+    admin: admin;
+    get: _get;
+    current: current;
+    update: update;
+    search: search;
+    access: access;
+    fields: fields;
+    userfield: userfield;
+}
+export interface iBXRestWorkpieceMethodsUserField<add, update, _delete, list, file extends iBXRestWorkpieceMethodsUserFieldList<file['get']>> {
+    /**
+     * Добавляет пользовательское поле
+     */
+    add: add;
+    /**
+     * Обновляет пользовательское поле
+     */
+    update: update;
+    /**
+     * Удаляет пользовательское поле
+     */
+    delete: _delete;
+    /**
+     *  Получает список пользовательских полей
+     */
+    list: list;
+    file: file;
+}
+export interface iBXRestWorkpieceMethodsUserFieldList<get> {
+    get: get;
+}
+export interface iBXRestWorkpieceMethodsTasks<task extends iBXRestWorkpieceMethodsTasksTask<task['add'], task['approve'], task['complete'], task['defer'], task['delegate'], task['get'], task['getFields'], task['getAccess'], task['list'], task['update'], iBXRestWorkpieceMethodsTasksTaskResult<task['result']['list'], task['result']['addFromComment'], task['result']['deleteFromComment']>>> {
+    task: task;
+}
+export interface iBXRestWorkpieceMethodsTasksTask<add, approve, complete, defer, delegate, _get, getFields, getAccess, list, update, result> {
+    add: add;
+    approve: approve;
+    complete: complete;
+    defer: defer;
+    delegate: delegate;
+    get: _get;
+    getFields: getFields;
+    getAccess: getAccess;
+    list: list;
+    update: update;
+    result: result;
+}
+export interface iBXRestWorkpieceMethodsTasksTaskResult<list, addFromComment, deleteFromComment> {
+    list: list;
+    addFromComment: addFromComment;
+    /**
+     * Удаление результата задачи по комментарию из которого он был создан
+     */
+    deleteFromComment: deleteFromComment;
+}
+export interface iBXRestWorkpieceMethodsTask<elapsedItem extends iBXRestWorkpieceMethodsTaskElapsedItem<elapsedItem['getList'], elapsedItem['add'], elapsedItem['delete'], elapsedItem['isActionAllowed'], elapsedItem['update']>, commentItem extends iBXRestWorkpieceMethodsTaskCommentItem<commentItem['getList'], commentItem['get'], commentItem['add'], commentItem['update'], commentItem['delete']>, planner extends iBXRestWorkpieceMethodsTaskPlanner<planner['getList']>, item extends iBXRestWorkpieceMethodsTaskItem<iBXRestWorkpieceMethodsTaskItemUserField<item['userField']['getList'], item['userField']['getFields']>>, stages extends iBXRestWorkpieceMethodsTaskStages<stages['add'], stages['canmovetask'], stages['delete'], stages['get'], stages['movetask'], stages['update']>> {
+    elapsedItem: elapsedItem;
+    commentItem: commentItem;
+    planner: planner;
+    item: item;
+    stages: stages;
+}
+export interface iBXRestWorkpieceMethodsTaskElapsedItem<getList, add, _delete, isActionAllowed, update> {
+    getList: getList;
+    add: add;
+    delete: _delete;
+    isActionAllowed: isActionAllowed;
+    update: update;
+}
+export interface iBXRestWorkpieceMethodsTaskCommentItem<getList, get, add, update, _delete> {
+    getList: getList;
+    get: get;
+    add: add;
+    update: update;
+    delete: _delete;
+}
+export interface iBXRestWorkpieceMethodsTaskPlanner<getList> {
+    getList: getList;
+}
+export interface iBXRestWorkpieceMethodsTaskItem<item extends iBXRestWorkpieceMethodsTaskItemUserField<item['getFields'], item['getList']>> {
+    userField: item;
+}
+export interface iBXRestWorkpieceMethodsTaskStages<add, canmovetask, _delete, _get, movetask, update> {
+    add: add;
+    canmovetask: canmovetask;
+    delete: _delete;
+    get: _get;
+    movetask: movetask;
+    update: update;
+}
+export interface iBXRestWorkpieceMethodsTaskItemUserField<getFields, getList> {
+    getFields: getFields;
+    getList: getList;
+}
+export interface iBXRestWorkpieceMethodsTimeman<status> {
+    /**
+     * Получение информации о текущем рабочем дне пользователя
+     */
+    status: status;
+}
+export interface iBXRestWorkpieceMethodsSonetGroup<_get> {
+    /**
+     * Возвращает массив групп соцсети, каждая из которых содержит массив полей, осуществляя вызов CSocNetGroup::GetList(), при этом возвращаются только те группы, которые доступны пользователю по правам
+     */
+    get: _get;
+}
+export interface iBXRestWorkpieceMethodsServer<time> {
+    /**
+     * Получить время сервера
+     */
+    time: time;
+}
+export interface iBXRestWorkpieceMethodsLog<blogpost extends iBXRestWorkpieceMethodsLogBlogpost<blogpost['add'], blogpost['get']>> {
+    blogpost: blogpost;
+}
+export interface iBXRestWorkpieceMethodsLogBlogpost<add, _get> {
+    /**
+     * Добавляет в Живую Ленту сообщение от имени текущего пользователя
+     */
+    add: add;
+    /**
+     * Возвращает массив с доступными текущему пользователю сообщениями Живой ленты.
+     * Каждое из сообщений представляет собой массив значений полей (включая пользовательские поля)
+     */
+    get: _get;
+}
+export interface iBXRestWorkpieceMethodsLists<_get, element extends iBXRestWorkpieceMethodsListsElement<element['add'], element['get']>, field extends iBXRestWorkpieceMethodsListsField<field['get']>> {
+    /**
+     * Метод возвращает данные по спискам
+     */
+    get: _get;
+    element: element;
+    field: field;
+}
+export interface iBXRestWorkpieceMethodsListsElement<add, _get> {
+    /**
+     * Метод создаёт элемент списка
+     */
+    add: add;
+    /**
+     * Метод возвращает список элементов или элемент
+     */
+    get: _get;
+}
+export interface iBXRestWorkpieceMethodsListsField<_get> {
+    /**
+     * Метод возвращает данные поля
+     */
+    get: _get;
+}
+export interface iBXRestWorkpieceMethodsIm<chat extends iBXRestWorkpieceMethodsImChat<chat['add']>> {
+    chat: chat;
+}
+export interface iBXRestWorkpieceMethodsImChat<add> {
+    add: add;
+}
+export interface iBXRestWorkpieceMethodsDisk<file extends iBXRestWorkpieceMethodsDiskFile<file['get'], file['markDeleted']>, folder extends iBXRestWorkpieceMethodsDiskFolder<folder['getFields'], folder['get'], folder['getChildren'], folder['addSubFolder'], folder['copyTo'], folder['moveTo'], folder['rename'], folder['deleteTree'], folder['markDeleted'], folder['restore'], folder['uploadFile'], folder['getExternalLink']>, attachedObject extends iBXRestWorkpieceMethodsDiskAttachedObject<attachedObject['get']>> {
+    file: file;
+    folder: folder;
+    attachedObject: attachedObject;
+}
+export interface iBXRestWorkpieceMethodsDiskFile<_get, markDeleted> {
+    /**
+     * Возвращает файл по идентификатору
+     */
+    get: _get;
+    /**
+     * Перемещает файл в корзину
+     */
+    markDeleted: markDeleted;
+}
+export interface iBXRestWorkpieceMethodsDiskFolder<getFields, _get, getChildren, addSubFolder, copyTo, moveTo, rename, deleteTree, markDeleted, restore, uploadFile, getExternalLink> {
+    getFields: getFields;
+    get: _get;
+    getChildren: getChildren;
+    addSubFolder: addSubFolder;
+    copyTo: copyTo;
+    moveTo: moveTo;
+    rename: rename;
+    deleteTree: deleteTree;
+    markDeleted: markDeleted;
+    restore: restore;
+    uploadFile: uploadFile;
+    getExternalLink: getExternalLink;
+}
+export interface iBXRestWorkpieceMethodsDiskAttachedObject<_get> {
+    get: _get;
+}
+export interface iBXRestWorkpieceMethodsDepartment<_get, del, add, update> {
+    get: _get;
+    del: del;
+    add: add;
+    update: update;
+}
+export interface iBXRestWorkpieceMethodsCalendar<event extends iBXRestWorkpieceMethodsCalendarEvent<event['get']>> {
+    event: event;
+}
+export interface iBXRestWorkpieceMethodsCalendarEvent<_get> {
+    /**
+     * Возвращает список событий календаря
+     */
+    get: _get;
+}
+export interface iBXRestWorkpieceMethodsBizProc<workflow extends iBXRestWorkpieceMethodsBizProcWorkflow<workflow['start']>> {
+    workflow: workflow;
+}
+export interface iBXRestWorkpieceMethodsBizProcWorkflow<start> {
+    /**
+     * Запускает Бизнес-процесс
+     */
+    start: start;
+}
+export interface iBXRestWorkpieceMethodsApp<info> {
+    /**
+     * Показ информации о приложении. Метод поддерживает безопасный вызов
+     */
+    info: info;
+}
+export interface iBXRestWorkpieceSocialNetWorkApiContentView<set> {
+    /**
+     * Чтобы отмечать пасты просмотренными (наверное)
+     */
+    set: set;
+}
+export interface iBXRestWorkpieceSocialNetWorkApiLiveFeed<blogPost> {
+    blogPost: blogPost;
+}
+export interface iBXRestWorkpieceSocialNetWorkApiLiveFeedBlogpost<important> {
+    important: important;
+}
+export interface iBXRestWorkpieceSocialNetWorkApiLiveFeedBlogpostImportant<vote> {
+    /**
+     * Чтобы подтверждать важные посты на прочтение
+     */
+    vote: vote;
+}
+export interface iBXRestWorkpieceSocialNetWorkApi<contentView, liveFeed> {
+    contentView: contentView;
+    liveFeed: liveFeed;
+}
+export interface iBXRestWorkpieceSocialNetWork<api> {
+    /**
+     * Пространство socialNetWork (не документировано)
+     */
+    api: api;
+}