hgs-twilio-class-lib 1.1.53 → 1.1.54

package/lib/twilio/impl/sync/SyncListItem.js

@@ -1 +1,22 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncListItems=void 0;const e=require("../../abstract/SyncServiceItemResource");class s extends e.SyncServiceItemResource{}exports.SyncListItems=s;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncListItems = void 0;
+const SyncServiceItemResource_1 = require("../../abstract/SyncServiceItemResource");
+class SyncListItems extends SyncServiceItemResource_1.SyncServiceItemResource {
+}
+exports.SyncListItems = SyncListItems;
+// Server                   
+//     Database1     IDatabase                   
+//         table1    IDatabaseOperations
+// record1
+// table2
+// record1
+// Database2
+// Sync - server / database     IDatabaseFactory  //flex2-1
+// Document - table / Records IDatabase 
+// List1 - Table1   IDatabaseObjectStore  
+// ListItem1 - record1
+// Map - Table      // gpm 
+// MapItem - record  // gpm-1 , gpm-2   use uuidv4 
+// IDBDatabase - database, creates Database -  is it  IDatabaseFactory 
+// IDBObjectStore - Table  IDatabase 

package/lib/twilio/impl/sync/SyncListTransaction.d.ts

@@ -0,0 +1,20 @@
+import { ServiceTransaction } from "../../abstract/ServiceTransaction";
+import { IServiceObjectStore } from "../../interface/IServiceObjectStore";
+import { IServiceResource } from "../../interface/IServiceResource";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+export declare class SyncListTransaction extends ServiceTransaction {
+    constructor(db: IServiceResource, mode: IDBTransactionMode, error?: DOMException | null, objectStoreNames?: DOMStringList, durability?: IDBTransactionDurability);
+    onabort: ((this: IDBTransaction, ev: Event) => any) | null;
+    oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
+    onerror: ((this: IDBTransaction, ev: Event) => any) | null;
+    abort(): void;
+    commit(): void;
+    objectStore(name: string): IServiceObjectStore;
+    addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IServiceTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IServiceTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: Event): boolean;
+}

package/lib/twilio/impl/sync/SyncListTransaction.js

@@ -1 +1,31 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncListTransaction=void 0;const e=require("../../abstract/ServiceTransaction");class t extends e.ServiceTransaction{constructor(e,t,r,o,n){super(e,t,r,o,n),this.onabort=null,this.oncomplete=null,this.onerror=null}abort(){throw new Error("Method not implemented.")}commit(){throw new Error("Method not implemented.")}objectStore(e){throw new Error("Method not implemented.")}addEventListener(e,t,r){throw new Error("Method not implemented.")}removeEventListener(e,t,r){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.SyncListTransaction=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncListTransaction = void 0;
+const ServiceTransaction_1 = require("../../abstract/ServiceTransaction");
+class SyncListTransaction extends ServiceTransaction_1.ServiceTransaction {
+    constructor(db, mode, error, objectStoreNames, durability) {
+        super(db, mode, error, objectStoreNames, durability);
+        this.onabort = null;
+        this.oncomplete = null;
+        this.onerror = null;
+    }
+    abort() {
+        throw new Error("Method not implemented.");
+    }
+    commit() {
+        throw new Error("Method not implemented.");
+    }
+    objectStore(name) {
+        throw new Error("Method not implemented.");
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.SyncListTransaction = SyncListTransaction;

package/lib/twilio/impl/sync/SyncMap.d.ts

@@ -0,0 +1,25 @@
+import { SearchParameterType } from "../../../common/type/SearchParameterType";
+import { ServiceObjectStore } from "../../abstract/ServiceObjectStore";
+export declare class SyncMap extends ServiceObjectStore {
+    constructor(name: string, transaction?: IDBTransaction, autoIncrement?: boolean, indexNames?: DOMStringList, keyPath?: string);
+    getMap(): IDBRequest<any>;
+    add(value: any, key?: IDBValidKey | undefined, ttl?: Number | undefined): IDBRequest<IDBValidKey>;
+    clear(): IDBRequest<undefined>;
+    count(query?: IDBValidKey | IDBKeyRange | undefined): IDBRequest<number>;
+    createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters | undefined): IDBIndex;
+    createIndex(name: string, keyPath: string | Iterable<string>, options?: IDBIndexParameters | undefined): IDBIndex;
+    createIndex(name: unknown, keyPath: unknown, options?: unknown): IDBIndex;
+    delete(query: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
+    delete(query: IDBValidKey | IDBKeyRange): Promise<IDBRequest<undefined>>;
+    deleteIndex(name: string): void;
+    get(query: IDBValidKey | IDBKeyRange): IDBRequest<any>;
+    getAll(query?: IDBValidKey | IDBKeyRange | null | undefined, count?: number | undefined): IDBRequest<any[]>;
+    getAll(query: SearchParameterType, count?: number | undefined): Promise<IDBRequest<any[]>>;
+    getAllKeys(query?: IDBValidKey | IDBKeyRange | null | undefined, count?: number | undefined): IDBRequest<IDBValidKey[]>;
+    getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
+    index(name: string): IDBIndex;
+    openCursor(query?: IDBValidKey | IDBKeyRange | null | undefined, direction?: IDBCursorDirection | undefined): IDBRequest<IDBCursorWithValue | null>;
+    openKeyCursor(query?: IDBValidKey | IDBKeyRange | null | undefined, direction?: IDBCursorDirection | undefined): IDBRequest<IDBCursor | null>;
+    put(value: any, key?: IDBValidKey | undefined): IDBRequest<IDBValidKey>;
+    put(value: Object, key: IDBValidKey): Promise<IDBRequest<IDBValidKey>>;
+}

package/lib/twilio/impl/sync/SyncMap.js

@@ -1 +1,139 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncMap=void 0;const e=require("../../../common/utils/pagination"),t=require("../../../common/utils/sort"),o=require("../../../common/utils/search"),n=require("../../../common/utils/newFilter"),r=require("../../../common/utils/dateFormat"),a=require("../../abstract/ServiceObjectStore"),s=require("./SyncMapTransaction"),i=require("../../../common/abstract/Filter");class c extends a.ServiceObjectStore{constructor(e,t,o,n,r){super(e,t,o,n,r)}getMap(){return s.SyncMapTransaction.syncMapInstance.fetch().then((e=>e))}add(e,t,o){return console.log("value ",e,t),s.SyncMapTransaction.syncMapInstance.syncMapItems.create({key:t,data:e,ttl:o})}clear(){throw new Error("Method not implemented.")}count(e){throw new Error("Method not implemented.")}createIndex(e,t,o){throw new Error("Method not implemented.")}delete(e){return s.SyncMapTransaction.syncMapInstance.syncMapItems(e).remove().then((e=>(console.log("delete map item ",e),"success"))).catch((e=>{throw e}))}deleteIndex(e){throw new Error("Method not implemented.")}get(e){return s.SyncMapTransaction.syncMapInstance.syncMapItems(e).fetch().then((e=>e.data))}getAll(a,c){return s.SyncMapTransaction.syncMapInstance.syncMapItems.list().then((s=>{let c=s.map((e=>e.data)),p=0;if(a&&"object"==typeof a&&"sortOptions"in a){let e,o;if("string"==typeof a.sortOptions&&(a.sortOptions=JSON.parse(a.sortOptions)),Array.isArray(a.sortOptions))a.sortOptions.forEach((n=>{Object.keys(n)[0]&&n[Object.keys(n)[0]]&&(e=Object.keys(n)[0],o="ASC"===n[Object.keys(n)[0]].toUpperCase()),c=(0,t.sortData)(c,e,o)}));else if(a.sortOptions){let n;n=a.sortOptions,Object.keys(a.sortOptions).forEach((r=>{n[r]&&(e=r,o="ASC"===n[r].toUpperCase()),c=(0,t.sortData)(c,e,o)}))}}let l=null;if(a&&"object"==typeof a&&"allowedFields"in a&&(l=i.Filter.generateFilterOptions(c,a.allowedFields)),a&&"object"==typeof a&&("timezone"in a||"dateFormat"in a||"timeFormat"in a)){let e="timezone"in a?a.timezone:"",t="dateFormat"in a?a.dateFormat:"",o="timeFormat"in a?a.timeFormat:"";c=(0,r.dateFormatData)(c,t,o,e)}if(a&&"object"==typeof a&&"filters"in a&&"category"in a){let e=a.filters,t="string"==typeof a.category?a.category:"";c=(0,n.filterData)(c,e,t)}if(a&&"object"==typeof a&&"searchOptions"in a&&a.searchOptions){let e="object"==typeof a&&"searchOptions"in a?a.searchOptions:"";c=(0,o.searchData)(c,e)}if(a&&"object"==typeof a&&"itemsPerPage"in a){let t="object"==typeof a&&"itemsPerPage"in a?a.itemsPerPage:5,o="object"==typeof a&&"pageNo"in a?a.pageNo:1;p=0!==c.length&&(t<c.length||t>c.length)?Math.ceil(c.length/t):1,c=(0,e.paginateData)(c,t,o)}return{totalPages:p,items:c,filterOptions:l}}))}getAllKeys(e,t){throw new Error("Method not implemented.")}getKey(e){throw new Error("Method not implemented.")}index(e){throw new Error("Method not implemented.")}openCursor(e,t){throw new Error("Method not implemented.")}openKeyCursor(e,t){throw new Error("Method not implemented.")}put(e,t){return s.SyncMapTransaction.syncMapInstance.syncMapItems(t).update({data:e}).then((e=>e.key))}}exports.SyncMap=c;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMap = void 0;
+const pagination_1 = require("../../../common/utils/pagination");
+const sort_1 = require("../../../common/utils/sort");
+const search_1 = require("../../../common/utils/search");
+const newFilter_1 = require("../../../common/utils/newFilter");
+const dateFormat_1 = require("../../../common/utils/dateFormat");
+const ServiceObjectStore_1 = require("../../abstract/ServiceObjectStore");
+const SyncMapTransaction_1 = require("./SyncMapTransaction");
+const Filter_1 = require("../../../common/abstract/Filter");
+class SyncMap extends ServiceObjectStore_1.ServiceObjectStore {
+    constructor(name, transaction, autoIncrement, indexNames, keyPath) {
+        super(name, transaction, autoIncrement, indexNames, keyPath);
+    }
+    getMap() {
+        return SyncMapTransaction_1.SyncMapTransaction.syncMapInstance.fetch().then((map) => {
+            return map;
+        });
+    }
+    add(value, key, ttl) {
+        console.log('value ', value, key);
+        return SyncMapTransaction_1.SyncMapTransaction.syncMapInstance.syncMapItems.create({ key: key, data: value, ttl: ttl });
+    }
+    clear() {
+        throw new Error("Method not implemented.");
+    }
+    count(query) {
+        throw new Error("Method not implemented.");
+    }
+    createIndex(name, keyPath, options) {
+        throw new Error("Method not implemented.");
+    }
+    delete(query) {
+        return SyncMapTransaction_1.SyncMapTransaction.syncMapInstance.syncMapItems(query).remove().then((mapItem) => {
+            console.log('delete map item ', mapItem);
+            return "success";
+        }).catch((error) => {
+            throw error;
+        });
+    }
+    deleteIndex(name) {
+        throw new Error("Method not implemented.");
+    }
+    get(query) {
+        return SyncMapTransaction_1.SyncMapTransaction.syncMapInstance.syncMapItems(query).fetch().then((mapItem) => {
+            return mapItem.data;
+        });
+    }
+    getAll(query, count) {
+        return SyncMapTransaction_1.SyncMapTransaction.syncMapInstance.syncMapItems.list().then((mapItems) => {
+            let items = mapItems.map((item) => item.data);
+            let totalPages = 0;
+            if (query && typeof query === 'object' && "sortOptions" in query) {
+                let sortBy;
+                let direction;
+                if (typeof query.sortOptions === "string") {
+                    query.sortOptions = JSON.parse(query.sortOptions);
+                }
+                if (Array.isArray(query.sortOptions)) {
+                    query.sortOptions.forEach(item => {
+                        if (Object.keys(item)[0] && item[Object.keys(item)[0]]) {
+                            sortBy = Object.keys(item)[0];
+                            direction = item[Object.keys(item)[0]].toUpperCase() === 'ASC' ? true : false;
+                        }
+                        items = (0, sort_1.sortData)(items, sortBy, direction);
+                    });
+                }
+                else if (query.sortOptions) {
+                    let sortOptions;
+                    sortOptions = query.sortOptions;
+                    Object.keys(query.sortOptions).forEach(item => {
+                        if (sortOptions[item]) {
+                            sortBy = item;
+                            direction = sortOptions[item].toUpperCase() === 'ASC' ? true : false;
+                        }
+                        items = (0, sort_1.sortData)(items, sortBy, direction);
+                    });
+                }
+            }
+            let filterOptions = null;
+            if (query && typeof query === 'object' && "allowedFields" in query) {
+                filterOptions = Filter_1.Filter.generateFilterOptions(items, query.allowedFields);
+            }
+            if (query && typeof query === 'object' && ("timezone" in query || "dateFormat" in query || "timeFormat" in query)) {
+                let timezone = "timezone" in query ? query.timezone : "";
+                let dateFormat = "dateFormat" in query ? query.dateFormat : "";
+                let timeFormat = "timeFormat" in query ? query.timeFormat : "";
+                items = (0, dateFormat_1.dateFormatData)(items, dateFormat, timeFormat, timezone);
+            }
+            if (query && typeof query === "object" && "filters" in query && "category" in query) {
+                let filters = query.filters;
+                let category = typeof query.category === "string" ? query.category : "";
+                items = (0, newFilter_1.filterData)(items, filters, category);
+            }
+            if (query && typeof query === 'object' && "searchOptions" in query && query.searchOptions) {
+                let searchOptions = typeof query === 'object' && "searchOptions" in query ? query.searchOptions : "";
+                items = (0, search_1.searchData)(items, searchOptions);
+            }
+            // if (query && typeof query === 'object' && "filters" in query && query.filters) {
+            //     let filters: any = typeof query === 'object' && "filters" in query ? query.filters : "";
+            //     // console.log("filtered data:::", typeof JSON.parse(filters));
+            //     items = filterData(items, filters)
+            // }
+            if (query && typeof query === 'object' && "itemsPerPage" in query) {
+                let itemsPerPage = typeof query === 'object' && "itemsPerPage" in query ? query.itemsPerPage : 5;
+                let pageNo = typeof query === 'object' && "pageNo" in query ? query.pageNo : 1;
+                totalPages = (items.length !== 0) && ((itemsPerPage < items.length) || (itemsPerPage > items.length)) ? Math.ceil(items.length / itemsPerPage) : 1;
+                items = (0, pagination_1.paginateData)(items, itemsPerPage, pageNo);
+            }
+            return {
+                totalPages,
+                items,
+                filterOptions
+            };
+        });
+    }
+    getAllKeys(query, count) {
+        throw new Error("Method not implemented.");
+    }
+    getKey(query) {
+        throw new Error("Method not implemented.");
+    }
+    index(name) {
+        throw new Error("Method not implemented.");
+    }
+    openCursor(query, direction) {
+        throw new Error("Method not implemented.");
+    }
+    openKeyCursor(query, direction) {
+        throw new Error("Method not implemented.");
+    }
+    put(value, key) {
+        return SyncMapTransaction_1.SyncMapTransaction.syncMapInstance.syncMapItems(key).update({ data: value }).then((mapItem) => {
+            return mapItem.key;
+        });
+    }
+}
+exports.SyncMap = SyncMap;

package/lib/twilio/impl/sync/SyncMapItem.d.ts

@@ -0,0 +1,5 @@
+import { SyncServiceItemResource } from "../../abstract/SyncServiceItemResource";
+export declare class SyncMapItem extends SyncServiceItemResource {
+    key: string;
+    sid: string;
+}

package/lib/twilio/impl/sync/SyncMapItem.js

@@ -1 +1,7 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncMapItem=void 0;const e=require("../../abstract/SyncServiceItemResource");class t extends e.SyncServiceItemResource{}exports.SyncMapItem=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMapItem = void 0;
+const SyncServiceItemResource_1 = require("../../abstract/SyncServiceItemResource");
+class SyncMapItem extends SyncServiceItemResource_1.SyncServiceItemResource {
+}
+exports.SyncMapItem = SyncMapItem;

package/lib/twilio/impl/sync/SyncMapTransaction.d.ts

@@ -0,0 +1,22 @@
+import { ServiceTransaction } from "../../abstract/ServiceTransaction";
+import { IServiceResource } from "../../interface/IServiceResource";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+import { SyncMap } from "./SyncMap";
+export declare class SyncMapTransaction extends ServiceTransaction {
+    private static _syncMapInstance;
+    constructor(db: IServiceResource, mode: IDBTransactionMode, error?: DOMException | null, objectStoreNames?: DOMStringList, durability?: IDBTransactionDurability);
+    static get syncMapInstance(): any;
+    onabort: ((this: IDBTransaction, ev: Event) => any) | null;
+    oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
+    onerror: ((this: IDBTransaction, ev: Event) => any) | null;
+    abort(): void;
+    commit(): void;
+    objectStore(name: string): SyncMap;
+    addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IServiceTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IServiceTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: Event): boolean;
+}

package/lib/twilio/impl/sync/SyncMapTransaction.js

@@ -1 +1,38 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncMapTransaction=void 0;const e=require("../../abstract/ServiceTransaction"),n=require("./SyncMap"),t=require("./SyncServiceFactory");class r extends e.ServiceTransaction{constructor(e,n,t,r,o){super(e,n,t,r,o),this.onabort=null,this.oncomplete=null,this.onerror=null}static get syncMapInstance(){return r._syncMapInstance}abort(){throw new Error("Method not implemented.")}commit(){throw new Error("Method not implemented.")}objectStore(e){return r._syncMapInstance=t.SyncServiceFactory.syncServiceInstance.syncMaps(e),console.log("map try ",r._syncMapInstance),new n.SyncMap(e,this)}addEventListener(e,n,t){throw new Error("Method not implemented.")}removeEventListener(e,n,t){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.SyncMapTransaction=r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMapTransaction = void 0;
+const ServiceTransaction_1 = require("../../abstract/ServiceTransaction");
+const SyncMap_1 = require("./SyncMap");
+const SyncServiceFactory_1 = require("./SyncServiceFactory");
+class SyncMapTransaction extends ServiceTransaction_1.ServiceTransaction {
+    constructor(db, mode, error, objectStoreNames, durability) {
+        super(db, mode, error, objectStoreNames, durability);
+        this.onabort = null;
+        this.oncomplete = null;
+        this.onerror = null;
+    }
+    static get syncMapInstance() {
+        return SyncMapTransaction._syncMapInstance;
+    }
+    abort() {
+        throw new Error("Method not implemented.");
+    }
+    commit() {
+        throw new Error("Method not implemented.");
+    }
+    objectStore(name) {
+        SyncMapTransaction._syncMapInstance = SyncServiceFactory_1.SyncServiceFactory.syncServiceInstance.syncMaps(name);
+        console.log('map try ', SyncMapTransaction._syncMapInstance);
+        return new SyncMap_1.SyncMap(name, this); // need to explore how to get the database transaction , which holds the connection
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.SyncMapTransaction = SyncMapTransaction;

package/lib/twilio/impl/sync/SyncOpenRequest.d.ts

@@ -0,0 +1,18 @@
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { IDatabaseRequest } from "../../../common/interface/IDatabaseRequest";
+import { ServiceDBOpenRequest } from "../../abstract/ServiceOpenRequest";
+import { IServiceDBOpenRequest } from "../../interface/IServiceDBOpenRequest";
+import { IServiceObjectStore } from "../../interface/IServiceObjectStore";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+export declare class SyncOpenDBRequest extends ServiceDBOpenRequest {
+    constructor(result: any, readyState: IDBRequestReadyState, error?: any | null, source?: IServiceObjectStore, transaction?: IServiceTransaction);
+    onblocked: ((this: IServiceDBOpenRequest, ev: IDBVersionChangeEvent) => any) | null;
+    onupgradeneeded: ((this: IServiceDBOpenRequest, ev: IDBVersionChangeEvent) => any) | null;
+    addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IServiceDBOpenRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IServiceDBOpenRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    onerror: ((this: IDatabaseRequest<IDatabase>, ev: Event) => any) | null;
+    onsuccess: ((this: IDatabaseRequest<IDatabase>, ev: Event) => any) | null;
+    dispatchEvent(event: Event): boolean;
+}

package/lib/twilio/impl/sync/SyncOpenRequest.js

@@ -1 +1,24 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncOpenDBRequest=void 0;const e=require("../../abstract/ServiceOpenRequest");class t extends e.ServiceDBOpenRequest{constructor(e,t,n,r,o){super(e,t,r,o,n),this.onblocked=null,this.onupgradeneeded=null,this.onerror=null,this.onsuccess=null,this.result=e}addEventListener(e,t,n){throw new Error("Method not implemented.")}removeEventListener(e,t,n){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.SyncOpenDBRequest=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncOpenDBRequest = void 0;
+const ServiceOpenRequest_1 = require("../../abstract/ServiceOpenRequest");
+class SyncOpenDBRequest extends ServiceOpenRequest_1.ServiceDBOpenRequest {
+    constructor(result, readyState, error, source, transaction) {
+        super(result, readyState, source, transaction, error);
+        this.onblocked = null;
+        this.onupgradeneeded = null;
+        this.onerror = null;
+        this.onsuccess = null;
+        this.result = result;
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.SyncOpenDBRequest = SyncOpenDBRequest;

package/lib/twilio/impl/sync/SyncRequest.d.ts

@@ -0,0 +1,16 @@
+import { ServiceRequest } from "../../abstract/ServiceRequest";
+import { IServiceObjectStore } from "../../interface/IServiceObjectStore";
+import { IServiceRequest } from "../../interface/IServiceRequest";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+export declare class SyncRequest extends ServiceRequest implements IServiceRequest<any> {
+    constructor(result: any, readyState: IDBRequestReadyState, error?: any | null, source?: IServiceObjectStore, transaction?: IServiceTransaction);
+    onerror: ((this: IServiceRequest<any>, ev: Event) => any) | null;
+    onsuccess: ((this: IServiceRequest<any>, ev: Event) => any) | null;
+    addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IServiceRequest<any>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IServiceRequest<any>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: Event): boolean;
+}

package/lib/twilio/impl/sync/SyncRequest.js

@@ -1 +1,21 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncRequest=void 0;const e=require("../../abstract/ServiceRequest");class t extends e.ServiceRequest{constructor(e,t,r,o,n){super(e,t,r,o,n),this.onerror=null,this.onsuccess=null}addEventListener(e,t,r){throw new Error("Method not implemented.")}removeEventListener(e,t,r){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.SyncRequest=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncRequest = void 0;
+const ServiceRequest_1 = require("../../abstract/ServiceRequest");
+class SyncRequest extends ServiceRequest_1.ServiceRequest {
+    constructor(result, readyState, error, source, transaction) {
+        super(result, readyState, error, source, transaction);
+        this.onerror = null;
+        this.onsuccess = null;
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.SyncRequest = SyncRequest;

package/lib/twilio/impl/sync/SyncResource.d.ts

@@ -0,0 +1,50 @@
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { ServiceResource } from "../../abstract/ServiceResource";
+import { IServiceObjectStoreParameters } from "../../interface/IServiceObjectStoreParameters";
+import { IServiceResource } from "../../interface/IServiceResource";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+import { ISyncTransactionOptions } from "../../interface/ISyncTransactionOptions";
+import { SyncDocument } from "./SyncDocument";
+import { SyncList } from "./SyncList";
+import { SyncMap } from "./SyncMap";
+export declare class SyncResource extends ServiceResource {
+    private _createdBy;
+    private _dateExpires;
+    private _revision;
+    private _serviceSid;
+    private _uniqueName;
+    private _url;
+    private static _syncResourceInstance;
+    constructor(name: string, version?: number);
+    static get syncResourceInstance(): any;
+    get createdBy(): string;
+    set createdBy(value: string);
+    get dateExpires(): Date;
+    set dateExpires(value: Date);
+    get revision(): string;
+    set revision(value: string);
+    get serviceSid(): string;
+    set serviceSid(value: string);
+    get uniqueName(): string;
+    set uniqueName(value: string);
+    get url(): string;
+    set url(value: string);
+    onabort: ((this: IDatabase, ev: Event) => any) | null;
+    onclose: ((this: IDatabase, ev: Event) => any) | null;
+    onerror: ((this: IDatabase, ev: Event) => any) | null;
+    onversionchange: ((this: IDatabase, ev: IDBVersionChangeEvent) => any) | null;
+    close(): void;
+    createObjectStore(name: string, options?: IServiceObjectStoreParameters): SyncMap | SyncDocument | SyncList;
+    fetchObjectStores(): SyncMap[] | SyncDocument[] | SyncDocument[];
+    deleteObjectStore(name: string): void;
+    transaction(storeNames: string | string[], mode?: IDBTransactionMode | undefined, options?: ISyncTransactionOptions | undefined): IServiceTransaction;
+    transaction(storeNames: string | Iterable<string>, mode?: IDBTransactionMode | undefined, options?: ISyncTransactionOptions | undefined): IServiceTransaction;
+    transaction(storeNames: unknown, mode?: unknown, options?: unknown): IServiceTransaction;
+    addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IServiceResource, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IServiceResource, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: Event): boolean;
+}

package/lib/twilio/impl/sync/SyncResource.js

@@ -1 +1,97 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SyncResource=void 0;const e=require("../../abstract/ServiceResource"),t=require("./SyncMapTransaction"),r=require("./SyncServiceFactory");class n extends e.ServiceResource{constructor(e,t=1){super(e,t),this.onabort=null,this.onclose=null,this.onerror=null,this.onversionchange=null}static get syncResourceInstance(){return this._syncResourceInstance}get createdBy(){return this._createdBy}set createdBy(e){this._createdBy=e}get dateExpires(){return this._dateExpires}set dateExpires(e){this._dateExpires=e}get revision(){return this._revision}set revision(e){this._revision=e}get serviceSid(){return this._serviceSid}set serviceSid(e){this._serviceSid=e}get uniqueName(){return this._uniqueName}set uniqueName(e){this._uniqueName=e}get url(){return this._url}set url(e){this._url=e}close(){throw new Error("Method not implemented.")}createObjectStore(e,t){throw new Error("Method not implemented.")}fetchObjectStores(){throw new Error("Method not implemented.")}deleteObjectStore(e){throw new Error("Method not implemented.")}transaction(e,s,i){return n._syncResourceInstance=r.SyncServiceFactory.syncServiceInstance,new t.SyncMapTransaction(r.SyncServiceFactory.syncServiceInstance,s)}addEventListener(e,t,r){throw new Error("Method not implemented.")}removeEventListener(e,t,r){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.SyncResource=n;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncResource = void 0;
+const ServiceResource_1 = require("../../abstract/ServiceResource");
+const SyncMapTransaction_1 = require("./SyncMapTransaction");
+const SyncServiceFactory_1 = require("./SyncServiceFactory");
+class SyncResource extends ServiceResource_1.ServiceResource {
+    constructor(name, version = 1) {
+        super(name, version);
+        // get dbConnection() {
+        //     return this._dbConnection;
+        // }
+        this.onabort = null;
+        this.onclose = null;
+        this.onerror = null;
+        this.onversionchange = null;
+    }
+    static get syncResourceInstance() {
+        return this._syncResourceInstance;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    set createdBy(value) {
+        this._createdBy = value;
+    }
+    get dateExpires() {
+        return this._dateExpires;
+    }
+    set dateExpires(value) {
+        this._dateExpires = value;
+    }
+    get revision() {
+        return this._revision;
+    }
+    set revision(value) {
+        this._revision = value;
+    }
+    get serviceSid() {
+        return this._serviceSid;
+    }
+    set serviceSid(value) {
+        this._serviceSid = value;
+    }
+    get uniqueName() {
+        return this._uniqueName;
+    }
+    set uniqueName(value) {
+        this._uniqueName = value;
+    }
+    get url() {
+        return this._url;
+    }
+    set url(value) {
+        this._url = value;
+    }
+    close() {
+        throw new Error("Method not implemented.");
+    }
+    createObjectStore(name, options) {
+        throw new Error("Method not implemented.");
+        // if (options?.serviceResourceType === 'Document') {
+        //     // return this.SyncDocuments.create({ uniqueName: name }).then({
+        //     // });
+        //     return this.db
+        // }
+        // return this.dbConnection;
+        // else if (options?.serviceResourceType === 'Map') {
+        //     return this.SyncMaps.create({ uniqueName: name });
+        // }
+        // else { //Consider default is List 
+        //     return this.syncLists.create({ uniqueName: name });
+        // }
+    }
+    fetchObjectStores() {
+        throw new Error("Method not implemented.");
+    }
+    deleteObjectStore(name) {
+        throw new Error("Method not implemented.");
+    }
+    transaction(storeNames, mode, options) {
+        //Not setting the storenames - need to be checked 
+        //
+        SyncResource._syncResourceInstance = SyncServiceFactory_1.SyncServiceFactory.syncServiceInstance;
+        return new SyncMapTransaction_1.SyncMapTransaction(SyncServiceFactory_1.SyncServiceFactory.syncServiceInstance, mode);
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.SyncResource = SyncResource;

package/lib/twilio/impl/sync/SyncServiceFactory.d.ts

@@ -0,0 +1,22 @@
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { ServiceResourceFactory } from "../../abstract/ServiceResourceFactory";
+import { IServiceDBOpenRequest } from "../../interface/IServiceDBOpenRequest";
+import { IServiceRequest } from "../../interface/IServiceRequest";
+import { IServiceResource } from "../../interface/IServiceResource";
+import { TwilioClient } from "../TwilioClient";
+export declare class SyncServiceFactory extends ServiceResourceFactory {
+    private _syncServiceSid?;
+    private static _syncServiceInstance;
+    constructor(twilioClient: TwilioClient);
+    static get syncServiceInstance(): any;
+    open(name: string, version: number): IServiceDBOpenRequest;
+    asyncOpen(name: string, version: number): Promise<IServiceDBOpenRequest>;
+    deleteDatabase(name: string): IServiceDBOpenRequest;
+    databases(name?: string): Promise<IServiceResource[]>;
+    create(database: IDatabase): Promise<IServiceRequest<IDatabase>>;
+    cmp(first: any, second: any): number;
+    getDatabase(): any;
+    private checkDatabaseExists;
+    private setDatabaseDetails;
+    private syncServiceOpen;
+}