bx-rest 0.0.18 → 0.0.20

package/request/lists/element.d.ts

@@ -0,0 +1,19 @@
+import iHttpAnswerBX from '../../typification/rest/base/httpAnswerBX';
+import HttpBXServices from '../../services/http/HttpBX';
+import BXRestListsElementMap from '../../map/lists/element';
+import { iBXRestHttpListsElement, iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
+export declare class BXRestListsElement {
+    private http;
+    private mapResult;
+    url: {
+        add: string[];
+        delete: string[];
+        get: string[];
+        update: string[];
+        getFileUrl: string[];
+    };
+    constructor(http: HttpBXServices, mapResult: BXRestListsElementMap);
+    get(pram: iBXRestParamListsElementGet): import("rxjs").Observable<(iHttpAnswerBX<iBXRestHttpListsElement[]> & {
+        result: import("../../typification/rest/lists/element/get").iBXRestListsElement[];
+    }) | undefined>;
+}

package/request/lists.d.ts

@@ -0,0 +1,15 @@
+import { BXRestListsElement } from './lists/element';
+import * as i0 from "@angular/core";
+export default class BXRestLists {
+    element: BXRestListsElement;
+    url: {
+        add: string[];
+        delete: string[];
+        get: string[];
+        update: string[];
+        getIblockTypeId: string[];
+    };
+    constructor(element: BXRestListsElement);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestLists, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestLists>;
+}

package/request/user.d.ts

@@ -0,0 +1,51 @@
+import { Observable } from 'rxjs';
+import { iBXGetParam } from '../typification/rest/user/get';
+import HttpBXServices from '../services/http/HttpBX';
+import UserFilterSearch from '../typification/rest/user/UserFilterSearch';
+import { Store } from '@ngrx/store';
+import { storeUsers } from '../store/users';
+import { BitrixApiUserMapServices } from '../services/map/rest/user';
+import SnackBarService from '../services/snack-bar/snack-bar.service';
+import iHttpAnswerBX from '../typification/rest/base/httpAnswerBX';
+import { iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '../typification/rest/user/user';
+import * as i0 from "@angular/core";
+export declare class BXRestUser {
+    private http;
+    private snackBar;
+    private store;
+    private userMap;
+    url: {
+        admin: string[];
+        get: string[];
+        current: string[];
+        update: string[];
+        search: string[];
+        access: string[];
+        fields: string[];
+        userfield: {
+            list: string[];
+        };
+    };
+    def: {
+        params: {
+            ACTIVE: 1;
+            start: 0;
+        };
+    };
+    user$: Observable<storeUsers>;
+    constructor(http: HttpBXServices, snackBar: SnackBarService, store: Store<{
+        users: storeUsers;
+    }>, userMap: BitrixApiUserMapServices);
+    admin(): Observable<iHttpAnswerBX<boolean> | undefined>;
+    get(params?: iBXGetParam): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined>;
+    current(update?: boolean): Observable<iBXRestUser | undefined>;
+    private getSelfHttp;
+    access(access: string[], textError?: string): Observable<iHttpAnswerBX<boolean> | undefined>;
+    private saveArrUser;
+    search(params: string | UserFilterSearch): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined>;
+    fields(): Observable<iHttpAnswerBX<iBXRestUserHttpField> | undefined>;
+    update(user: iBXRestUser, fieldUpdate: string[]): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined> | Observable<{}>;
+    private setDefParam;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestUser, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestUser>;
+}

package/rest.d.ts

@@ -0,0 +1,14 @@
+import { BXRestUser } from './request/user';
+import BXRestLists from './request/lists';
+import * as i0 from "@angular/core";
+declare class BXRestBase {
+    user: BXRestUser;
+    lists: BXRestLists;
+    constructor(user: BXRestUser, lists: BXRestLists);
+}
+declare const BXRest_base: typeof BXRestBase;
+export declare class BXRest extends BXRest_base {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRest, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRest>;
+}
+export {};

package/services/base.d.ts

@@ -0,0 +1,32 @@
+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): "N" | "Y";
+    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;
+    getHomeAddress(): 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>;
+}

package/services/http/HttpBX.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { iHttpParamSettings } from '../../typification/rest/settings';
+import BaseHttpServices from '../../services/http/http';
+import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp } from '../../typification/rest/batch/batchRequestParam';
+import * as i0 from "@angular/core";
+export default class HttpBXServices extends BaseHttpServices {
+    timeNowOnServer(): Observable<Date | undefined>;
+    /**
+     * Это пиздец а не метод
+     * @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[];
+    post<T>(name: string[], params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    get<T>(name: string[], params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpPost<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    getNameMethod(arr: string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpBXServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpBXServices>;
+}

package/services/http/HttpData.d.ts

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

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

@@ -0,0 +1,16 @@
+import { iHttpParamSettings } from '../../../typification/rest/settings';
+import { HttpClient } from '@angular/common/http';
+import SnackBarService from '../../../services/snack-bar/snack-bar.service';
+import { Observable } from 'rxjs';
+import { HttpData } from '../../../services/http/HttpData';
+import * as i0 from "@angular/core";
+export declare abstract class BaseHttp extends HttpData {
+    http: HttpClient;
+    snackBar: SnackBarService;
+    protected constructor(http: HttpClient, snackBar: SnackBarService);
+    abstract httpGet<T>(url: string, params: any, textError: string, settings: iHttpParamSettings): Observable<T | undefined>;
+    abstract httpPost<T>(url: string, params: any, textError: string, settings: iHttpParamSettings): Observable<T | undefined>;
+    handleError<T>(result?: T, textError?: string): (error: Error) => Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseHttp>;
+}

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

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { iHttpParamSettings } from '../../../typification/rest/settings';
+import { BaseHttp } from '../../../services/http/base/base';
+export declare class BaseHttpServices extends BaseHttp {
+    httpGet<T>(url: string, params?: {}, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpPost<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+}

package/services/http/http.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import SnackBarService from '../../services/snack-bar/snack-bar.service';
+import SessionKeyServices from '../../services/http/sessionKey';
+import { iHttpParamSettings } from '../../typification/rest/settings';
+import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp } from '../../typification/rest/batch/batchRequestParam';
+import { BaseHttpServices } from './base/http';
+import * as i0 from "@angular/core";
+export default class HttpServices extends BaseHttpServices {
+    session: SessionKeyServices;
+    constructor(http: HttpClient, snackBar: SnackBarService, session: SessionKeyServices);
+    timeNowOnServer(): Observable<Date | undefined>;
+    /**
+     * Это пиздец а не метод
+     * @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[];
+    post<T>(name: string[], params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    get<T>(name: string[], params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpPost<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    httpGet<T>(url: string, params?: any, textError?: string, settings?: iHttpParamSettings): Observable<T | undefined>;
+    getNameMethod(arr: string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpServices>;
+}

package/services/http/sessionKey.d.ts

@@ -0,0 +1,34 @@
+import { Store } from '@ngrx/store';
+import saveApplicationAuth from '../../typification/auth/save';
+import { Observable, Subscription } from 'rxjs';
+import { ActivatedRoute } from '@angular/router';
+import { BaseServices } from '../../services/base';
+import { RestServices } from '../../typification/rest/api-lib';
+import * as i0 from "@angular/core";
+declare type IKeyAuth = 'sessid' | 'auth' | string;
+export default class SessionKeyServices extends BaseServices {
+    store: Store<{
+        auth: saveApplicationAuth;
+    }>;
+    private route;
+    BxApiLib: RestServices;
+    authHave: boolean;
+    authData$: Observable<saveApplicationAuth>;
+    authData: saveApplicationAuth | undefined;
+    subscribe: {
+        authData: Subscription;
+    };
+    constructor(store: Store<{
+        auth: saveApplicationAuth;
+    }>, route: ActivatedRoute, BxApiLib: RestServices);
+    subscribeAll(): void;
+    getAuth(): string;
+    getKeyAuth(): IKeyAuth;
+    getSessid(): any;
+    setAuthParams<T>(params: any): boolean;
+    getAuthParams(): Observable<string | undefined>;
+    getBaseUrl(): Observable<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionKeyServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionKeyServices>;
+}
+export {};

package/services/map/base.d.ts

@@ -0,0 +1,6 @@
+import { BaseServices } from '../base';
+import * as i0 from "@angular/core";
+export default class BaseMapServices extends BaseServices {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMapServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseMapServices>;
+}

package/services/map/rest/user.d.ts

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

package/services/snack-bar/snack-bar.service.d.ts

@@ -0,0 +1,12 @@
+import { MatSnackBar } from '@angular/material/snack-bar';
+import * as i0 from "@angular/core";
+export default class SnackBarService {
+    private snackBar;
+    constructor(snackBar: MatSnackBar);
+    error(message: string, sec?: number): void;
+    warning(message: string, sec?: number): void;
+    success(message: string, sec?: number): void;
+    standardMessage(message: string, sec?: number, name?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SnackBarService>;
+}

package/services/snack-bar/toast-message/toast-message.component.d.ts

@@ -0,0 +1,16 @@
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+import * as i0 from "@angular/core";
+export declare class ToastMessageComponent {
+    data: {
+        message: string;
+        type: 'error' | 'warning' | 'success';
+    };
+    snackBarRef: MatSnackBarRef<any>;
+    constructor(data: {
+        message: string;
+        type: 'error' | 'warning' | 'success';
+    });
+    getClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastMessageComponent, "app-view", never, {}, {}, never, never, true, never>;
+}

package/services/vanilla/JSON.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export default class JSONServices {
+    static deserialize(data: any): any;
+    static serialize(data: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JSONServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JSONServices>;
+}

package/services/vanilla/localStorage.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageServices>;
+}

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

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiesServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CookiesServices>;
+}

package/store/auth.d.ts

@@ -0,0 +1,20 @@
+import { Action } from '@ngrx/store';
+import saveApplicationAuth from '../typification/auth/save';
+export interface saveApplicationAuthPath {
+    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;
+    type?: string;
+}
+export declare const save: import("@ngrx/store").ActionCreator<"[Auth Component] Save", (props: saveApplicationAuth | saveApplicationAuthPath) => (saveApplicationAuth | saveApplicationAuthPath) & import("@ngrx/store/src/models").TypedAction<"[Auth Component] Save">>;
+export declare const saveAccessToken: import("@ngrx/store").ActionCreator<"[Auth Component] SaveAccessToken", (props: saveApplicationAuthPath) => saveApplicationAuthPath & import("@ngrx/store/src/models").TypedAction<"[Auth Component] SaveAccessToken">>;
+export declare const initialState: saveApplicationAuth;
+export declare function authReducer(state: saveApplicationAuth | undefined, action: Action): saveApplicationAuth;

package/store/users.d.ts

@@ -0,0 +1,34 @@
+import { Action } from '@ngrx/store';
+import { iBXRestUser } from '../typification/rest/user/user';
+export interface storeUsers {
+    load: {
+        all: boolean;
+        department: number[];
+    };
+    self: iBXRestUser | undefined;
+    data: iBXRestUser[];
+}
+export declare const save: import("@ngrx/store").ActionCreator<"[Users Component] Save", (props: iBXRestUser) => iBXRestUser & import("@ngrx/store/src/models").TypedAction<"[Users Component] Save">>;
+export declare const saveArr: import("@ngrx/store").ActionCreator<"[Users Component] Save Arr", (props: {
+    arr: iBXRestUser[];
+}) => {
+    arr: iBXRestUser[];
+} & import("@ngrx/store/src/models").TypedAction<"[Users Component] Save Arr">>;
+export declare const update: import("@ngrx/store").ActionCreator<"[Users Component] Update", (props: iBXRestUser) => iBXRestUser & import("@ngrx/store/src/models").TypedAction<"[Users Component] Update">>;
+export declare const loadAll: import("@ngrx/store").ActionCreator<"[Users Component] loadAll", (props: {
+    load: true;
+}) => {
+    load: true;
+} & import("@ngrx/store/src/models").TypedAction<"[Users Component] loadAll">>;
+export declare const saveSelf: import("@ngrx/store").ActionCreator<"[Users Component] saveSelf", (props: {
+    self: iBXRestUser;
+}) => {
+    self: iBXRestUser;
+} & import("@ngrx/store/src/models").TypedAction<"[Users Component] saveSelf">>;
+export declare const saveIDLoadedDepartment: import("@ngrx/store").ActionCreator<"[Users Component] saveIDLoadedDepartment", (props: {
+    id: number[];
+}) => {
+    id: number[];
+} & import("@ngrx/store/src/models").TypedAction<"[Users Component] saveIDLoadedDepartment">>;
+export declare const initialState: storeUsers;
+export declare function usersReducer(state: storeUsers | undefined, action: Action): storeUsers;

package/typification/auth/save.d.ts

@@ -0,0 +1,14 @@
+export default interface saveApplicationAuth {
+    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/rest/api-lib.d.ts

@@ -0,0 +1,9 @@
+import { iRestLib } from './lib';
+import * as i0 from "@angular/core";
+export declare class RestServices {
+    BX24: iRestLib | false;
+    constructor();
+    init(callBack: Function): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RestServices>;
+}

package/typification/rest/base/YesNo.d.ts

@@ -0,0 +1 @@
+export declare type iBXRestYesNo = 'Y' | 'N';

package/typification/rest/base/httpAnswerBX.d.ts

@@ -0,0 +1,15 @@
+export default interface iHttpAnswerBX<T> {
+    result?: T | undefined;
+    next?: number;
+    total?: number;
+    time?: {
+        start: number;
+        finish: number;
+        duration: number;
+        processing: number;
+        date_start: string;
+        date_finish: string;
+    };
+    error?: string;
+    error_description?: string;
+}

package/typification/rest/batch/batchRequestParam.d.ts

@@ -0,0 +1,16 @@
+import iHttpAnswerBX from '../../../typification/rest/base/httpAnswerBX';
+export declare type keyBatch = string | number;
+export interface iBatchRequestParam<T> {
+    name: string;
+    param: T;
+}
+export declare type iBatchRequestParamHttp = {
+    [key: keyBatch]: string;
+};
+export declare type iBatchRequestParamArr<T> = {
+    [key: keyBatch]: iBatchRequestParam<T>;
+};
+export interface iBatchRequestAnswer<T> extends iHttpAnswerBX<iHttpAnswerBX<{
+    [key: keyBatch]: T;
+}>> {
+}

package/typification/rest/lib.d.ts

@@ -0,0 +1,18 @@
+export interface iRestLib {
+    init: Function;
+    getAuth: () => iRestLibGetAuth;
+    placement: {
+        info: () => {
+            options: any;
+            placement: string;
+        };
+    };
+    fitWindow: (func?: () => void) => void;
+}
+export interface iRestLibGetAuth {
+    access_token: string;
+    domain: string;
+    expires_in: number;
+    member_id: string;
+    refresh_token: string;
+}

package/typification/rest/lists/element/get.d.ts

@@ -0,0 +1,28 @@
+import { iBXRestYesNo } from '../../base/YesNo';
+export interface iBXRestParamListsElementGet {
+    IBLOCK_TYPE_ID: 'lists' | 'bitrix_processes' | 'lists_socnet';
+    IBLOCK_ID: number;
+    SOCNET_GROUP_ID?: number;
+    ELEMENT_ID?: number;
+    FILTER?: {
+        [key: string]: any;
+    };
+}
+export interface iBXRestListsElement extends iBXRestBaseListsElement {
+    BP_PUBLISHED: boolean;
+    CREATED_BY: number;
+    IBLOCK_ID: number;
+    ID: number;
+}
+export interface iBXRestHttpListsElement extends iBXRestBaseListsElement {
+    BP_PUBLISHED: iBXRestYesNo;
+    CREATED_BY: string;
+    IBLOCK_ID: string;
+    ID: string;
+}
+export interface iBXRestBaseListsElement {
+    CODE: string | null;
+    IBLOCK_SECTION_ID: string | null;
+    NAME: string;
+    [key: string]: any;
+}

package/typification/rest/settings.d.ts

@@ -0,0 +1,6 @@
+export interface iHttpParamSettings {
+    timeZone: {
+        calc: boolean;
+        levelOut: boolean;
+    };
+}

package/typification/rest/support/param.d.ts

@@ -0,0 +1,5 @@
+export interface iBXRestBaseParam {
+    start?: number;
+}
+export interface iBXRestBaseParamFactor<T extends iBXRestBaseParam> {
+}

package/typification/rest/user/UserFilterSearch.d.ts

@@ -0,0 +1,43 @@
+export default interface UserFilterSearch {
+    NAME?: string;
+    LAST_NAME?: string;
+    SECOND_NAME?: string;
+    WORK_POSITION?: string;
+    UF_DEPARTMENT_NAME?: string;
+    USER_TYPE?: 'employee' | 'extranet' | 'email';
+    FIND?: string;
+    ACTIVE?: boolean;
+    EMAIL?: string;
+    LAST_LOGIN?: string;
+    DATE_REGISTER?: string;
+    IS_ONLINE?: 'Y' | 'N';
+    PERSONAL_GENDER?: 'M' | 'F';
+    PERSONAL_PROFESSION?: string;
+    PERSONAL_WWW?: string;
+    PERSONAL_BIRTHDAY?: string;
+    PERSONAL_PHOTO?: string;
+    PERSONAL_ICQ?: string;
+    PERSONAL_PHONE?: string;
+    PERSONAL_FAX?: string;
+    PERSONAL_MOBILE?: string;
+    PERSONAL_PAGER?: string;
+    PERSONAL_STREET?: string;
+    PERSONAL_CITY?: string;
+    PERSONAL_STATE?: string;
+    PERSONAL_ZIP?: string;
+    PERSONAL_COUNTRY?: string;
+    TIME_ZONE_OFFSET?: string;
+    WORK_COMPANY?: string;
+    WORK_PHONE?: string;
+    UF_DEPARTMENT?: number[];
+    UF_INTERESTS?: string;
+    UF_SKILLS?: string;
+    UF_WEB_SITES?: string;
+    UF_XING?: string;
+    UF_LINKEDIN?: string;
+    UF_FACEBOOK?: string;
+    UF_TWITTER?: string;
+    UF_SKYPE?: string;
+    UF_DISTRICT?: string;
+    UF_PHONE_INNER?: string;
+}

package/typification/rest/user/get.d.ts

@@ -0,0 +1,13 @@
+import { iBXRestYesNo } from '../base/YesNo';
+import { iBXRestBaseParam } from '../support/param';
+export interface iBXGetParam extends iBXRestBaseParam {
+    ID?: number[] | number;
+    PERSONAL_BIRTHDAY?: string | string[];
+    order?: 'ASC' | 'DESC';
+    UF_DEPARTMENT?: number[];
+    UF_PHONE_INNER?: string;
+    IS_ONLINE?: iBXRestYesNo;
+    NAME_SEARCH?: string;
+    USER_TYPE?: 'employee' | 'extranet' | 'email';
+    ACTIVE?: 2 | 1 | 0;
+}