bx-rest 0.1.6 → 0.1.9

package/map/base.d.ts

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

package/map/calendar/event.d.ts

@@ -0,0 +1,9 @@
+import { BaseMapServices } from '../base';
+import { iBXRestCalendarEventGetAnswer, iBXRestCalendarEventGetAnswerHttp } from '../../typification/rest/calendar/get/answer';
+import * as i0 from "@angular/core";
+export declare class BXRestMapCalendarEvent extends BaseMapServices {
+    get(item: iBXRestCalendarEventGetAnswerHttp[] | undefined): iBXRestCalendarEventGetAnswer[] | undefined;
+    private CalendarEventGetAnswerHttpToCalendarEventGetAnswer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapCalendarEvent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapCalendarEvent>;
+}

package/map/disk/attachedObject.d.ts

@@ -0,0 +1,9 @@
+import BXRestMapDiskBase from './base';
+import { iBXRestDiskAttachedObject, iBXRestDiskAttachedObjectHttp } from '../../typification/rest/disk/AttachedObject';
+import * as i0 from "@angular/core";
+export default class BXRestMapDiskAttachedObject extends BXRestMapDiskBase {
+    get(v: iBXRestDiskAttachedObjectHttp | undefined): iBXRestDiskAttachedObject | undefined;
+    private iBXRestDiskAttachedObjectHttpToiBXRestDiskAttachedObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapDiskAttachedObject, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapDiskAttachedObject>;
+}

package/map/disk/base.d.ts

@@ -1,4 +1,4 @@
-import BaseMapServices from '../base';
+import { BaseMapServices } from '../base';
 import { iBXRestFile, iBXRestFileHttp } from '../../typification/rest/disk/file';
 import { iBXRestFolder, iBXRestFolderHttp } from '../../typification/rest/disk/folder';
 import { iBXRestFileAndFolderMap } from '../../typification/rest/disk/map';

package/map/lists/element.d.ts

@@ -1,4 +1,4 @@
-import BaseMapServices from '../base';
+import { BaseMapServices } from '../base';
 import { iBXRestHttpListsElement, iBXRestListsElement } from '../../typification/rest/lists/element/get';
 import * as i0 from "@angular/core";
 export default class BXRestMapListsElement extends BaseMapServices {

package/map/lists.d.ts

@@ -1,9 +1,12 @@
-import BaseMapServices from './base';
+import { BaseMapServices } from './base';
 import BXRestListsElementMap from './lists/element';
+import { iBXRestListItem, iBXRestListItemHttp } from '../typification/rest/lists/get';
 import * as i0 from "@angular/core";
 export declare class BXRestMapLists extends BaseMapServices {
     element: BXRestListsElementMap;
     constructor(element: BXRestListsElementMap);
+    get(value: iBXRestListItemHttp[] | undefined): iBXRestListItem[] | undefined;
+    private iBXRestListItemHttpToiBXRestListItem;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapLists, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapLists>;
 }

package/map/sonet_group.d.ts

@@ -0,0 +1,9 @@
+import { BaseMapServices } from './base';
+import { iBXRestParamSonet, iBXRestParamSonetHttp } from '../typification/rest/sonet_group/get';
+import * as i0 from "@angular/core";
+export declare class BXRestMapSonetGroup extends BaseMapServices {
+    get(items: iBXRestParamSonetHttp[] | undefined): iBXRestParamSonet[] | undefined;
+    private iBXRestParamSonetHttpToiBXRestParamSonet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestMapSonetGroup, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestMapSonetGroup>;
+}

package/map/task.d.ts

@@ -1,4 +1,4 @@
-import BaseMapServices from './base';
+import { BaseMapServices } from './base';
 import { iBXRestHttpTask, iBXRestTask } from '../typification/rest/task/task';
 import * as i0 from "@angular/core";
 export declare class BXRestTaskMap extends BaseMapServices {

package/map/user.d.ts

@@ -1,4 +1,4 @@
-import BaseMapServices from './base';
+import { BaseMapServices } from './base';
 import { iBXRestUser, iBXRestUserHttp } from '../typification/rest/user/user';
 import * as i0 from "@angular/core";
 export declare class BXRestUserMap extends BaseMapServices {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bx-rest",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "bitrix rest api",
   "keywords": [
     "bitrxi",

package/request/bizproc/workflow/template.d.ts

@@ -1,5 +1,5 @@
 import { iBXRestParamBizprocWorkflowTemplateList } from '../../../typification/rest/bizproc/workflow/template/list';
-import HttpBXServices from '../../../services/http/HttpBX';
+import { HttpBXServices } from '../../../services/http/HttpBX';
 import * as i0 from "@angular/core";
 export declare class BXRestBizprocWorkflowTemplate {
     private http;

package/request/bizproc/workflow.d.ts

@@ -1,6 +1,6 @@
 import { BXRestBizprocWorkflowInstance } from './workflow/instance';
 import { BXRestBizprocWorkflowTemplate } from './workflow/template';
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestParamBizprocWorkflowStart } from '../../typification/rest/bizproc/workflow/start';
 import * as i0 from "@angular/core";
 export declare class BXRestBizprocWorkflow {

package/request/calendar/event.d.ts

@@ -0,0 +1,18 @@
+import { HttpBXServices } from '../../services/http/HttpBX';
+import { iBXRestCalendarEventGetParam } from '../../typification/rest/calendar/get/param';
+import { iBXRestCalendarEventGetAnswerHttp } from '../../typification/rest/calendar/get/answer';
+import * as i0 from "@angular/core";
+export declare class BXRestCalendarEvent {
+    private http;
+    url: {
+        add: string[];
+        delete: string[];
+        get: string[];
+        getNearest: string[];
+        update: string[];
+    };
+    constructor(http: HttpBXServices);
+    get(param: iBXRestCalendarEventGetParam): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestCalendarEventGetAnswerHttp[]> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestCalendarEvent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestCalendarEvent>;
+}

package/request/calendar.d.ts

@@ -0,0 +1,8 @@
+import { BXRestCalendarEvent } from './calendar/event';
+import * as i0 from "@angular/core";
+export declare class BXRestCalendar {
+    event: BXRestCalendarEvent;
+    constructor(event: BXRestCalendarEvent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestCalendar, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestCalendar>;
+}

package/request/disk/attachedObject.d.ts

@@ -0,0 +1,13 @@
+import { HttpBXServices } from '../../services/http/HttpBX';
+import { iBXRestDiskAttachedObjectHttp } from '../../typification/rest/disk/AttachedObject';
+import * as i0 from "@angular/core";
+export declare class BXRestDiskAttachedObject {
+    private http;
+    url: {
+        get: string[];
+    };
+    constructor(http: HttpBXServices);
+    get(id: number): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestDiskAttachedObjectHttp> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDiskAttachedObject, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDiskAttachedObject>;
+}

package/request/disk/file.d.ts

@@ -1,4 +1,4 @@
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestFileHttp } from '../../typification/rest/disk/file';
 import * as i0 from "@angular/core";
 export declare class BXRestDiskFile {

package/request/disk/folder.d.ts

@@ -1,4 +1,4 @@
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestFolderHttp } from '../../typification/rest/disk/folder';
 import { iBXRestFileHttp } from '../../typification/rest/disk/file';
 import * as i0 from "@angular/core";

package/request/disk/storage.d.ts

@@ -1,4 +1,4 @@
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestFile, iBXRestFileHttp } from '../../typification/rest/disk/file';
 import { iBXRestFolderHttp, iBXRestFolderInfo } from '../../typification/rest/disk/folder';
 import { iBXRestParamUploadFile } from '../../typification/rest/disk/storage/uploadfile';

package/request/disk.d.ts

@@ -1,10 +1,12 @@
 import { BXRestDiskFile } from './disk/file';
 import { BXRestDiskFolder } from './disk/folder';
+import { BXRestDiskAttachedObject } from './disk/attachedObject';
 import * as i0 from "@angular/core";
 export declare class BXRestDisk {
     file: BXRestDiskFile;
     folder: BXRestDiskFolder;
-    constructor(file: BXRestDiskFile, folder: BXRestDiskFolder);
+    attachedObject: BXRestDiskAttachedObject;
+    constructor(file: BXRestDiskFile, folder: BXRestDiskFolder, attachedObject: BXRestDiskAttachedObject);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDisk, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDisk>;
 }

package/request/lists/element.d.ts

@@ -1,4 +1,4 @@
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestHttpListsElement, iBXRestParamListsElementGet } from '../../typification/rest/lists/element/get';
 import { iBXRestParamListsElementAdd } from '../../typification/rest/lists/element/add';
 import * as i0 from "@angular/core";

package/request/lists.d.ts

@@ -1,7 +1,10 @@
 import { BXRestListsElement } from './lists/element';
+import { HttpBXServices } from '../services/http/HttpBX';
+import { iBXRestListItemHttp, iBXRestParamListGet } from '../typification/rest/lists/get';
 import * as i0 from "@angular/core";
 export declare class BXRestLists {
     element: BXRestListsElement;
+    private http;
     url: {
         add: string[];
         delete: string[];
@@ -9,7 +12,8 @@ export declare class BXRestLists {
         update: string[];
         getIblockTypeId: string[];
     };
-    constructor(element: BXRestListsElement);
+    constructor(element: BXRestListsElement, http: HttpBXServices);
+    get(pram: iBXRestParamListGet): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<iBXRestListItemHttp[]> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestLists, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestLists>;
 }

package/request/log/blogpost.d.ts

@@ -1,5 +1,6 @@
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestParamLogBlogPostAdd } from '../../typification/rest/log/blogpost/add';
+import { iBXRestBlogPostHttp, iBXRestParamBlogPostGet } from '../../typification/rest/log/blogpost/get';
 import * as i0 from "@angular/core";
 export declare class BXRestLogBlogPost {
     private http;
@@ -12,6 +13,7 @@ export declare class BXRestLogBlogPost {
     };
     constructor(http: HttpBXServices);
     add(param: iBXRestParamLogBlogPostAdd): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<boolean> | undefined>;
+    get(param?: iBXRestParamBlogPostGet): import("rxjs").Observable<import("../../typification/rest/base/answer").iBXRestAnswer<iBXRestBlogPostHttp[]> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestLogBlogPost, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestLogBlogPost>;
 }

package/request/sonet_group.d.ts

@@ -0,0 +1,17 @@
+import { HttpBXServices } from '../services/http/HttpBX';
+import { iBXRestParamSonetGroupGet, iBXRestParamSonetHttp } from '../typification/rest/sonet_group/get';
+import * as i0 from "@angular/core";
+export declare class BXRestSonetGroup {
+    private http;
+    url: {
+        create: string[];
+        delete: string[];
+        get: string[];
+        setowner: string[];
+        update: string[];
+    };
+    constructor(http: HttpBXServices);
+    get(param?: iBXRestParamSonetGroupGet): import("rxjs").Observable<import("../typification/rest/base/answer").iBXRestAnswer<iBXRestParamSonetHttp[]> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestSonetGroup, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestSonetGroup>;
+}

package/request/tasks/task.d.ts

@@ -1,4 +1,4 @@
-import HttpBXServices from '../../services/http/HttpBX';
+import { HttpBXServices } from '../../services/http/HttpBX';
 import { iBXRestHttpTask } from '../../typification/rest/task/task';
 import { iBXRestParamTaskAdd } from '../../typification/rest/tasks/task/add';
 import iBXRestParamTaskGet from '../../typification/rest/tasks/task/get';

package/request/user.d.ts

@@ -1,5 +1,5 @@
 import { iBXRestParamUserGet } from '../typification/rest/user/get';
-import HttpBXServices from '../services/http/HttpBX';
+import { HttpBXServices } from '../services/http/HttpBX';
 import UserFilterSearch from '../typification/rest/user/UserFilterSearch';
 import { iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '../typification/rest/user/user';
 import { iBXRestAnswer } from '../typification/rest/base/answer';

package/request-navvy/calendar/event.d.ts

@@ -0,0 +1,14 @@
+import { iBXRestCalendarEventGetParam } from '../../typification/rest/calendar/get/param';
+import { BXRestCalendarEvent } from '../../request/calendar/event';
+import { Navvy } from '../../services/navvy';
+import { BXRestMapCalendarEvent } from '../../map/calendar/event';
+import * as i0 from "@angular/core";
+export declare class BXRestRestCalendarEvent {
+    private BXRestCalendarEvent;
+    private Navvy;
+    private eventMap;
+    constructor(BXRestCalendarEvent: BXRestCalendarEvent, Navvy: Navvy, eventMap: BXRestMapCalendarEvent);
+    get(param: iBXRestCalendarEventGetParam): import("rxjs").Observable<import("../../typification/rest/calendar/get/answer").iBXRestCalendarEventGetAnswer[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestRestCalendarEvent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestRestCalendarEvent>;
+}

package/request-navvy/calendar.d.ts

@@ -0,0 +1,8 @@
+import { BXRestRestCalendarEvent } from './calendar/event';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyCalendar {
+    event: BXRestRestCalendarEvent;
+    constructor(event: BXRestRestCalendarEvent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyCalendar, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyCalendar>;
+}

package/request-navvy/disk/attachedObject.d.ts

@@ -0,0 +1,13 @@
+import { BXRestDiskAttachedObject } from '../../request/disk/attachedObject';
+import { Navvy } from '../../services/navvy';
+import BXRestMapDiskAttachedObject from '../../map/disk/attachedObject';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvyDiskAttachedObject {
+    private BXRestDiskAttachedObject;
+    private mapAttachedObject;
+    private Navvy;
+    constructor(BXRestDiskAttachedObject: BXRestDiskAttachedObject, mapAttachedObject: BXRestMapDiskAttachedObject, Navvy: Navvy);
+    get(id: number): import("rxjs").Observable<import("../../typification/rest/disk/AttachedObject").iBXRestDiskAttachedObject | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDiskAttachedObject, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDiskAttachedObject>;
+}

package/request-navvy/disk/folder.d.ts

@@ -2,12 +2,12 @@ import BXRestMapDiskFolder from '../../map/disk/folder';
 import { BXRestDiskFolder } from '../../request/disk/folder';
 import { Navvy } from '../../services/navvy';
 import * as i0 from "@angular/core";
-export declare class BXRestDiskNavvyFolder {
+export declare class BXRestNavvyDiskFolder {
     private BXRestDiskFolder;
     private BXRestMapDiskFolder;
     private Navvy;
     constructor(BXRestDiskFolder: BXRestDiskFolder, BXRestMapDiskFolder: BXRestMapDiskFolder, Navvy: Navvy);
     getchildren(id: number): import("rxjs").Observable<import("../../typification/rest/disk/map").iBXRestFileAndFolderMap>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestDiskNavvyFolder, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestDiskNavvyFolder>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDiskFolder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDiskFolder>;
 }

package/request-navvy/disk/operation.d.ts

@@ -1,12 +1,12 @@
-import { BXRestDiskNavvyFolder } from './folder';
+import { BXRestNavvyDiskFolder } from './folder';
 import { BXRestNavvyDiskFile } from './file';
 import { BXRestNavvyDiskStorage } from './storage';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyDiskOperation {
-    folder: BXRestDiskNavvyFolder;
+    folder: BXRestNavvyDiskFolder;
     disk: BXRestNavvyDiskFile;
     private storage;
-    constructor(folder: BXRestDiskNavvyFolder, disk: BXRestNavvyDiskFile, storage: BXRestNavvyDiskStorage);
+    constructor(folder: BXRestNavvyDiskFolder, disk: BXRestNavvyDiskFile, storage: BXRestNavvyDiskStorage);
     loadFileInAppFolder(file: {
         name: string;
         val: string;

package/request-navvy/disk.d.ts

@@ -1,12 +1,14 @@
 import { BXRestNavvyDiskFile } from './disk/file';
-import { BXRestDiskNavvyFolder } from './disk/folder';
+import { BXRestNavvyDiskFolder } from './disk/folder';
 import { BXRestNavvyDiskOperation } from './disk/operation';
+import { BXRestNavvyDiskAttachedObject } from './disk/attachedObject';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyDisk {
-    file: BXRestNavvyDiskFile;
-    folder: BXRestDiskNavvyFolder;
     operation: BXRestNavvyDiskOperation;
-    constructor(file: BXRestNavvyDiskFile, folder: BXRestDiskNavvyFolder, operation: BXRestNavvyDiskOperation);
+    file: BXRestNavvyDiskFile;
+    folder: BXRestNavvyDiskFolder;
+    attachedObject: BXRestNavvyDiskAttachedObject;
+    constructor(operation: BXRestNavvyDiskOperation, file: BXRestNavvyDiskFile, folder: BXRestNavvyDiskFolder, attachedObject: BXRestNavvyDiskAttachedObject);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyDisk, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyDisk>;
 }

package/request-navvy/lists.d.ts

@@ -1,8 +1,16 @@
 import { BXRestNavvyListsElement } from './lists/element';
+import { BXRestLists } from '../request/lists';
+import { iBXRestParamListGet } from '../typification/rest/lists/get';
+import { Navvy } from '../services/navvy';
+import { BXRestMapLists } from '../map/lists';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyLists {
     element: BXRestNavvyListsElement;
-    constructor(element: BXRestNavvyListsElement);
+    private BXRestLists;
+    private Navvy;
+    private mapList;
+    constructor(element: BXRestNavvyListsElement, BXRestLists: BXRestLists, Navvy: Navvy, mapList: BXRestMapLists);
+    get(param: iBXRestParamListGet): import("rxjs").Observable<import("../typification/rest/lists/get").iBXRestListItem[] | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyLists, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyLists>;
 }

package/request-navvy/log/blogpost.d.ts

@@ -1,6 +1,7 @@
 import { iBXRestParamLogBlogPostAdd } from '../../typification/rest/log/blogpost/add';
 import { BXRestLogBlogPost } from '../../request/log/blogpost';
 import { Navvy } from '../../services/navvy';
+import { iBXRestParamBlogPostGet } from '../../typification/rest/log/blogpost/get';
 import * as i0 from "@angular/core";
 export declare class BXRestNavvyLogBlogPost {
     private BXRestLogBlogPost;
@@ -14,6 +15,7 @@ export declare class BXRestNavvyLogBlogPost {
     };
     constructor(BXRestLogBlogPost: BXRestLogBlogPost, Navvy: Navvy);
     add(param: iBXRestParamLogBlogPostAdd): import("rxjs").Observable<boolean | undefined>;
+    get(param?: iBXRestParamBlogPostGet): import("rxjs").Observable<import("../../typification/rest/log/blogpost/get").iBXRestBlogPostHttp[] | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvyLogBlogPost, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvyLogBlogPost>;
 }

package/request-navvy/sonet_group.d.ts

@@ -0,0 +1,14 @@
+import { iBXRestParamSonetGroupGet } from '../typification/rest/sonet_group/get';
+import { BXRestMapSonetGroup } from '../map/sonet_group';
+import { Navvy } from '../services/navvy';
+import { BXRestSonetGroup } from '../request/sonet_group';
+import * as i0 from "@angular/core";
+export declare class BXRestNavvySonetGroup {
+    private BXRestSonetGroup;
+    private mapSonetGroup;
+    private Navvy;
+    constructor(BXRestSonetGroup: BXRestSonetGroup, mapSonetGroup: BXRestMapSonetGroup, Navvy: Navvy);
+    get(param?: iBXRestParamSonetGroupGet): import("rxjs").Observable<import("../typification/rest/sonet_group/get").iBXRestParamSonet[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvySonetGroup, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvySonetGroup>;
+}

package/rest.d.ts

@@ -5,12 +5,16 @@ import { BXRestTasks } from './request/tasks';
 import { BXRestDisk } from './request/disk';
 import { BXRestBizproc } from './request/bizproc';
 import { BXRestLog } from './request/log';
+import { BXRestCalendar } from './request/calendar';
+import { BXRestSonetGroup } from './request/sonet_group';
 import { BXRestNavvyLists } from './request-navvy/lists';
 import { BXRestNavvyTasks } from './request-navvy/tasks';
 import { BXRestNavvyUser } from './request-navvy/user';
 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 * as i0 from "@angular/core";
 export declare class BXRest {
     user: BXRestUser;
@@ -19,7 +23,9 @@ export declare class BXRest {
     disk: BXRestDisk;
     bizproc: BXRestBizproc;
     log: BXRestLog;
-    constructor(user: BXRestUser, lists: BXRestLists, tasks: BXRestTasks, disk: BXRestDisk, bizproc: BXRestBizproc, log: BXRestLog);
+    calendar: BXRestCalendar;
+    sonet_group: BXRestSonetGroup;
+    constructor(user: BXRestUser, lists: BXRestLists, tasks: BXRestTasks, disk: BXRestDisk, bizproc: BXRestBizproc, log: BXRestLog, calendar: BXRestCalendar, sonet_group: BXRestSonetGroup);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRest, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRest>;
 }
@@ -30,7 +36,9 @@ export declare class BXRestNavvy {
     disk: BXRestNavvyDisk;
     bizproc: BXRestNavvyBizproc;
     log: BXRestNavvyLog;
-    constructor(user: BXRestNavvyUser, lists: BXRestNavvyLists, tasks: BXRestNavvyTasks, disk: BXRestNavvyDisk, bizproc: BXRestNavvyBizproc, log: BXRestNavvyLog);
+    calendar: BXRestNavvyCalendar;
+    sonet_group: BXRestNavvySonetGroup;
+    constructor(user: BXRestNavvyUser, lists: BXRestNavvyLists, tasks: BXRestNavvyTasks, disk: BXRestNavvyDisk, bizproc: BXRestNavvyBizproc, log: BXRestNavvyLog, calendar: BXRestNavvyCalendar, sonet_group: BXRestNavvySonetGroup);
     static ɵfac: i0.ɵɵFactoryDeclaration<BXRestNavvy, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BXRestNavvy>;
 }

package/services/http/HttpBX.d.ts

@@ -4,7 +4,7 @@ import { HttpServices } from './http';
 import { iBatchRequestAnswer, iBatchRequestParam, iBatchRequestParamArr, iBatchRequestParamHttp } from '../../typification/rest/batch/batchRequestParam';
 import { iBXRestAnswer } from '../../typification/rest/base/answer';
 import * as i0 from "@angular/core";
-export default class HttpBXServices extends HttpServices {
+export declare class HttpBXServices extends HttpServices {
     timeNowOnServer(): Observable<Date | undefined>;
     /**
      * Это пиздец а не метод

package/typification/base/modyfy.d.ts

@@ -0,0 +1,9 @@
+export declare type Modify<T, R> = Omit<T, keyof R> & R;
+export declare 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];
+};
+declare type AnyObject = Record<string, any>;
+declare type DeepPartialAny<T> = {
+    [P in keyof T]?: T[P] extends AnyObject ? DeepPartialAny<T[P]> : any;
+};
+export {};

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

@@ -0,0 +1,3 @@
+export interface iBXRestPagination {
+    start?: number;
+}

package/typification/rest/calendar/base/type.d.ts

@@ -0,0 +1 @@
+export declare type iBXRestCalendarType = 'user' | 'group';

package/typification/rest/calendar/get/answer.d.ts

@@ -0,0 +1,126 @@
+import { CountryCode, TimezoneName } from 'countries-and-timezones';
+import { iBXRestYesNo } from '../../base/YesNo';
+import { iBXRestCalendarType } from '../base/type';
+export interface iBXRestCalendarEventGetAnswer extends iBXRestCalendarEventGetAnswerBase {
+    ATTENDEE_LIST: {
+        id: number;
+        entryId: number;
+        status: 'Y' | 'N' | 'H';
+    }[];
+    CREATED_BY: string;
+    DATE_CREATE: Date;
+    DATE_FROM: Date;
+    DATE_FROM_TS_UTC: number;
+    DATE_TO: Date;
+    DATE_TO_TS_UTC: number;
+    DELETED: boolean;
+    DT_LENGTH: number;
+    DT_SKIP_TIME: boolean;
+    MEETING_STATUS: boolean;
+    EXDATE: Date[];
+    ID: number;
+    MEETING_HOST: number;
+    ORIGINAL_DATE_FROM: Date | null;
+    OWNER_ID: number;
+    PARENT_ID: number;
+    RECURRENCE_ID: number;
+    SECTION_ID: number;
+    SECT_ID: number;
+    TIMESTAMP_X: Date;
+    TZ_OFFSET_FROM: number;
+    TZ_OFFSET_TO: number;
+    VERSION: number;
+    RRULE: null | iBXRestCalendarEventGetAnswerRule;
+}
+export interface iBXRestCalendarEventGetAnswerHttp extends iBXRestCalendarEventGetAnswerBase {
+    ATTENDEE_LIST?: {
+        id: number;
+        entryId: string;
+        status: 'Y' | 'N' | 'H';
+    }[];
+    CREATED_BY: string;
+    DATE_CREATE: string;
+    DATE_FROM: string;
+    DATE_FROM_TS_UTC: string;
+    DATE_TO: string;
+    DATE_TO_TS_UTC: string;
+    DELETED: iBXRestYesNo;
+    DT_LENGTH: string;
+    DT_SKIP_TIME: iBXRestYesNo;
+    MEETING_STATUS: iBXRestYesNo;
+    EXDATE: string;
+    ID: string;
+    MEETING_HOST: string;
+    ORIGINAL_DATE_FROM: string | null;
+    OWNER_ID: string;
+    PARENT_ID: string;
+    RECURRENCE_ID: string;
+    RRULE: "" | iBXRestCalendarEventGetAnswerRuleHttp;
+    SECTION_ID: string;
+    SECT_ID: string;
+    TIMESTAMP_X: string;
+    TZ_OFFSET_FROM: string;
+    TZ_OFFSET_TO: string;
+    VERSION: string;
+}
+export interface iBXRestCalendarEventGetAnswerBase {
+    ACCESSIBILITY: 'busy';
+    ATTENDEES_CODES: string[];
+    CAL_DAV_LABEL: null;
+    CAL_TYPE: iBXRestCalendarType;
+    COLOR: string;
+    DAV_EXCH_LABEL: null;
+    DAV_XML_ID: string;
+    EVENT_TYPE: null;
+    G_EVENT_ID: null;
+    IMPORTANCE: 'normal';
+    IS_MEETING: boolean;
+    LOCATION: string;
+    RINDEX?: number;
+    MEETING: {
+        ALLOW_INVITE: boolean;
+        HIDE_GUESTS: boolean;
+        HOST_NAME: string;
+        LANGUAGE_ID: Lowercase<CountryCode>;
+        MAIL_FROM: string;
+        MEETING_CREATOR: number;
+        NOTIFY: boolean;
+        REINVITE: boolean;
+    };
+    NAME: string;
+    PRIVATE_EVENT: "";
+    RELATIONS: {
+        COMMENT_XML_ID: string;
+    };
+    REMIND: {
+        type: 'min';
+        count: number;
+    }[];
+    SYNC_STATUS: null;
+    TZ_FROM: TimezoneName;
+    TZ_TO: TimezoneName;
+    UF_CRM_CAL_EVENT: boolean;
+    UF_WEBDAV_CAL_EVENT: boolean;
+    attendeesEntityList: {
+        entityId: iBXRestCalendarType;
+        id: number;
+    }[];
+    '~USER_OFFSET_FROM': number;
+    '~USER_OFFSET_TO': number;
+}
+interface iBXRestCalendarEventGetAnswerRuleHttp extends iBXRestCalendarEventGetAnswerRuleBase {
+    UNTIL: string;
+    '~UNTIL': string;
+}
+interface iBXRestCalendarEventGetAnswerRule extends iBXRestCalendarEventGetAnswerRuleBase {
+    UNTIL: Date;
+    '~UNTIL': Date;
+}
+declare type iBXRestCalendarEventGetAnswerRuleBase = {
+    FR?: 'FR';
+    MO?: 'MO';
+    WE?: 'WE';
+    FREQ: 'WEEKLY';
+    INTERVAL: number;
+};
+export {};

package/typification/rest/calendar/get/param.d.ts

@@ -0,0 +1,8 @@
+import { iBXRestCalendarType } from '../base/type';
+export interface iBXRestCalendarEventGetParam {
+    type: iBXRestCalendarType;
+    ownerId?: number;
+    from?: Date;
+    to?: Date;
+    section?: any;
+}