nylas 6.1.0 → 6.2.1

package/lib/models/attributes.d.ts

@@ -1,5 +1,5 @@
 import Model from './model';
-import RestfulModel from './restful-model';
+declare type AnyModel = new (...args: any[]) => Model;
 export declare abstract class Attribute {
     modelKey: string;
     jsonKey: string;
@@ -18,7 +18,7 @@ declare class AttributeObject extends Attribute {
     constructor({ modelKey, jsonKey, itemClass, readOnly, }: {
         modelKey: string;
         jsonKey?: string;
-        itemClass?: typeof Model | typeof RestfulModel;
+        itemClass?: AnyModel;
         readOnly?: boolean;
     });
     toJSON(val: any, saveRequestBody?: boolean): unknown;
@@ -58,12 +58,12 @@ declare class AttributeCollection extends Attribute {
     constructor({ modelKey, jsonKey, itemClass, readOnly, }: {
         modelKey: string;
         jsonKey?: string;
-        itemClass: typeof Model | typeof RestfulModel;
+        itemClass: AnyModel;
         readOnly?: boolean;
     });
-    toJSON(vals: any, saveRequestBody?: boolean): unknown[];
-    fromJSON(json: unknown[], _parent: any): typeof Model[] | typeof RestfulModel[] | unknown[];
-    saveRequestBody(val: any): unknown;
+    toJSON(vals: any, saveRequestBody?: boolean): AnyModel[];
+    fromJSON(json: unknown[], _parent: any): AnyModel[];
+    saveRequestBody(val: any): AnyModel[] | undefined;
 }
 declare class AttributeEnum extends Attribute {
     itemClass: any;
@@ -121,7 +121,7 @@ declare const Attributes: {
     Collection(__0: {
         modelKey: string;
         jsonKey?: string | undefined;
-        itemClass: typeof Model | typeof RestfulModel;
+        itemClass: AnyModel;
         readOnly?: boolean | undefined;
     }): AttributeCollection;
     Boolean(__0: {
@@ -132,7 +132,7 @@ declare const Attributes: {
     Object(__0: {
         modelKey: string;
         jsonKey?: string | undefined;
-        itemClass?: typeof Model | typeof RestfulModel | undefined;
+        itemClass?: AnyModel | undefined;
         readOnly?: boolean | undefined;
     }): AttributeObject;
     Enum(__0: {

package/lib/models/attributes.js

@@ -19,15 +19,11 @@ var __spreadArrays = (this && this.__spreadArrays) || function () {
             r[k] = a[j];
     return r;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var restful_model_1 = __importDefault(require("./restful-model"));
-// The Attribute class represents a single model attribute, like 'namespace_id'
-// Subclasses of Attribute like AttributeDateTime know how to covert between
-// the JSON representation of that type and the javascript representation.
-// The Attribute class also exposes convenience methods for generating Matchers.
+function isRestfulModel(cls) {
+    // A 'RestfulModel' has 'endpointName' and 'collectionName' unlike 'Model'
+    return cls.endpointName !== undefined && cls.collectionName !== undefined;
+}
 var Attribute = /** @class */ (function () {
     function Attribute(_a) {
         var modelKey = _a.modelKey, jsonKey = _a.jsonKey, readOnly = _a.readOnly;
@@ -68,8 +64,8 @@ var AttributeObject = /** @class */ (function (_super) {
         if (!val || !this.itemClass) {
             return val;
         }
-        if (this.itemClass.prototype instanceof restful_model_1.default) {
-            return new this.itemClass(_parent.connection).fromJSON(val);
+        if (isRestfulModel(this.itemClass)) {
+            return new this.itemClass(_parent.connection, val).fromJSON(val);
         }
         return new this.itemClass(val).fromJSON(val);
     };
@@ -239,8 +235,8 @@ var AttributeCollection = /** @class */ (function (_super) {
         for (var _i = 0, json_1 = json; _i < json_1.length; _i++) {
             var objJSON = json_1[_i];
             var obj = void 0;
-            if (this.itemClass.prototype instanceof restful_model_1.default) {
-                obj = new this.itemClass(_parent.connection).fromJSON(objJSON);
+            if (isRestfulModel(this.itemClass)) {
+                obj = new this.itemClass(_parent.connection, objJSON).fromJSON(objJSON);
             }
             else {
                 obj = new this.itemClass(objJSON).fromJSON(objJSON);
@@ -286,16 +282,18 @@ var AttributeEnumList = /** @class */ (function (_super) {
     }
     AttributeEnumList.prototype.toJSON = function (val) {
         var enumList = [];
-        for (var v in val) {
+        for (var _i = 0, val_1 = val; _i < val_1.length; _i++) {
+            var v = val_1[_i];
             enumList.push(v.toString());
         }
         return enumList;
     };
     AttributeEnumList.prototype.fromJSON = function (val, _parent) {
         var enumList = [];
-        for (var v in val) {
-            if (Object.values(this.itemClass).includes(val[v])) {
-                enumList.push(val[v]);
+        for (var _i = 0, val_2 = val; _i < val_2.length; _i++) {
+            var v = val_2[_i];
+            if (Object.values(this.itemClass).includes(v)) {
+                enumList.push(v);
             }
         }
         return enumList;

package/lib/models/connect.d.ts

@@ -19,9 +19,7 @@ export declare enum Scope {
 export declare type VirtualCalendarProperties = {
     name: string;
     emailAddress: string;
-    scopes: Scope[];
     clientId?: string;
-    settings?: Record<string, any>;
 };
 export declare class VirtualCalendar extends Model implements VirtualCalendarProperties {
     provider: string;
@@ -45,6 +43,7 @@ export declare enum NativeAuthenticationProvider {
     Office365 = "office365"
 }
 export declare type NativeAuthenticationProperties = VirtualCalendarProperties & {
+    scopes: Scope[];
     settings: Record<string, any>;
     provider: NativeAuthenticationProvider;
 };

package/lib/models/connect.js

@@ -41,9 +41,9 @@ var VirtualCalendar = /** @class */ (function (_super) {
         _this.provider = 'nylas';
         _this.name = '';
         _this.emailAddress = '';
-        _this.scopes = [];
         _this.settings = {};
         _this.initAttributes(props);
+        _this.scopes = [Scope.Calendar];
         return _this;
     }
     VirtualCalendar.attributes = {
@@ -149,7 +149,7 @@ var Connect = /** @class */ (function () {
         if (!auth.clientId) {
             auth.clientId = this.clientId;
         }
-        if (auth.hasOwnProperty('scopes')) {
+        if (auth.hasOwnProperty('provider') && auth.provider != 'nylas') {
             authClass = new NativeAuthentication(auth);
         }
         else {

package/lib/models/delta-collection.d.ts

@@ -0,0 +1,17 @@
+import NylasConnection from '../nylas-connection';
+import DeltaStream, { DeltaLongPoll } from './delta-stream';
+import { DeltaParams } from './delta';
+import { Deltas } from './deltas';
+export declare type LatestCursor = {
+    cursor: string;
+};
+export default class DeltaCollection {
+    connection: NylasConnection;
+    private path;
+    constructor(connection: NylasConnection);
+    latestCursor(callback: (error: Error | null, cursor: string | null) => void): Promise<string>;
+    since(cursor: string, params?: DeltaParams): Promise<Deltas>;
+    longPoll(cursor: string, timeout: number, params?: DeltaParams): Promise<DeltaLongPoll>;
+    startStream(cursor: string, params?: Record<string, unknown>): Promise<DeltaStream>;
+    private buildDeltaParams;
+}

package/lib/models/delta-collection.js

@@ -0,0 +1,139 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var delta_stream_1 = __importStar(require("./delta-stream"));
+var deltas_1 = require("./deltas");
+var DeltaCollection = /** @class */ (function () {
+    function DeltaCollection(connection) {
+        this.path = '/delta';
+        this.connection = connection;
+    }
+    DeltaCollection.prototype.latestCursor = function (callback) {
+        var reqOpts = {
+            method: 'POST',
+            path: this.path + "/latest_cursor",
+        };
+        return this.connection
+            .request(reqOpts)
+            .then(function (response) {
+            if (callback) {
+                callback(null, response.cursor);
+            }
+            return Promise.resolve(response.cursor);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err, null);
+            }
+            return Promise.reject(err);
+        });
+    };
+    DeltaCollection.prototype.since = function (cursor, params) {
+        var _this = this;
+        var queryParams = this.buildDeltaParams(params);
+        return this.connection
+            .request({
+            method: 'GET',
+            path: "" + this.path,
+            qs: __assign({ cursor: cursor }, queryParams),
+        })
+            .then(function (response) {
+            return Promise.resolve(new deltas_1.Deltas(_this.connection).fromJSON(response));
+        })
+            .catch(function (err) {
+            return Promise.reject(err);
+        });
+    };
+    DeltaCollection.prototype.longPoll = function (cursor, timeout, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParams, stream;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParams = this.buildDeltaParams(params);
+                        stream = new delta_stream_1.DeltaLongPoll(this.connection, cursor, timeout, queryParams);
+                        return [4 /*yield*/, stream.open(true)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, stream];
+                }
+            });
+        });
+    };
+    DeltaCollection.prototype.startStream = function (cursor, params) {
+        if (params === void 0) { params = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var stream;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        stream = new delta_stream_1.default(this.connection, cursor, params);
+                        return [4 /*yield*/, stream.open()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, stream];
+                }
+            });
+        });
+    };
+    DeltaCollection.prototype.buildDeltaParams = function (params) {
+        return __assign(__assign(__assign({}, ((params === null || params === void 0 ? void 0 : params.view) && { view: params.view })), ((params === null || params === void 0 ? void 0 : params.excludeTypes) && {
+            exclude_types: params.excludeTypes.join(),
+        })), ((params === null || params === void 0 ? void 0 : params.includeTypes) && { includeTypes: params.includeTypes.join() }));
+    };
+    return DeltaCollection;
+}());
+exports.default = DeltaCollection;

package/lib/models/delta-stream.d.ts

@@ -4,15 +4,15 @@ import NylasConnection from '../nylas-connection';
 import { Request } from 'node-fetch';
 import AbortController from 'abort-controller';
 import backoff from 'backoff';
+import Delta, { DeltaParams } from './delta';
+import { Deltas } from './deltas';
 export default class DeltaStream extends EventEmitter {
     static MAX_RESTART_RETRIES: number;
     connection: NylasConnection;
+    path: string;
+    modelClass: typeof Deltas | typeof Delta;
     cursor?: string;
-    params: {
-        includeTypes?: string[];
-        excludeTypes?: string[];
-        expanded?: boolean;
-    };
+    params: DeltaParams;
     requestInfo?: {
         request: Request;
         controller: AbortController;
@@ -21,8 +21,12 @@ export default class DeltaStream extends EventEmitter {
     timeoutId?: number;
     constructor(connection: NylasConnection, cursor: string, params?: Record<string, unknown>);
     close(): void;
-    open(): Promise<void>;
-    private onDataReceived;
+    open(emitAsModel?: boolean): Promise<void>;
+    protected onDataReceived(): void;
     private onError;
     private restartConnection;
 }
+export declare class DeltaLongPoll extends DeltaStream {
+    constructor(connection: NylasConnection, cursor: string, timeout: number, params?: Record<string, unknown>);
+    protected onDataReceived(): void;
+}

package/lib/models/delta-stream.js

@@ -90,6 +90,7 @@ var abort_controller_1 = __importDefault(require("abort-controller"));
 var backoff_1 = __importDefault(require("backoff"));
 var JSONStream_1 = __importDefault(require("JSONStream"));
 var delta_1 = __importDefault(require("./delta"));
+var deltas_1 = require("./deltas");
 var DeltaStream = /** @class */ (function (_super) {
     __extends(DeltaStream, _super);
     // @param {string} cursor Nylas delta API cursor
@@ -109,6 +110,8 @@ var DeltaStream = /** @class */ (function (_super) {
         _this.connection = connection;
         _this.cursor = cursor;
         _this.params = params;
+        _this.path = '/delta/streaming';
+        _this.modelClass = delta_1.default;
         if (!(_this.connection instanceof nylas_connection_1.default)) {
             throw new Error('Connection object not provided');
         }
@@ -129,15 +132,14 @@ var DeltaStream = /** @class */ (function (_super) {
         }
         delete this.requestInfo;
     };
-    DeltaStream.prototype.open = function () {
+    DeltaStream.prototype.open = function (emitAsModel) {
         return __awaiter(this, void 0, void 0, function () {
-            var path, _a, _b, excludeTypes, _c, includeTypes, params, queryObj, request, controller, response, error_1;
+            var _a, _b, excludeTypes, _c, includeTypes, params, queryObj, request, controller, response, error_1;
             var _this = this;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         this.close();
-                        path = '/delta/streaming';
                         _a = this.params, _b = _a.excludeTypes, excludeTypes = _b === void 0 ? [] : _b, _c = _a.includeTypes, includeTypes = _c === void 0 ? [] : _c, params = __rest(_a, ["excludeTypes", "includeTypes"]);
                         queryObj = __assign(__assign({}, params), { cursor: this.cursor });
                         if (excludeTypes.length > 0) {
@@ -148,7 +150,7 @@ var DeltaStream = /** @class */ (function (_super) {
                         }
                         request = this.connection.newRequest({
                             method: 'GET',
-                            path: path,
+                            path: this.path,
                             qs: queryObj,
                         });
                         _d.label = 1;
@@ -185,6 +187,9 @@ var DeltaStream = /** @class */ (function (_super) {
                                 // JSONStream.parse(), which handles converting data blocks to JSON objects.
                                 .pipe(JSONStream_1.default.parse())
                                 .on('data', function (obj) {
+                                if (emitAsModel === true) {
+                                    obj = new _this.modelClass(_this.connection).fromJSON(obj);
+                                }
                                 if (obj.cursor) {
                                     _this.cursor = obj.cursor;
                                 }
@@ -223,3 +228,23 @@ var DeltaStream = /** @class */ (function (_super) {
     return DeltaStream;
 }(events_1.EventEmitter));
 exports.default = DeltaStream;
+var DeltaLongPoll = /** @class */ (function (_super) {
+    __extends(DeltaLongPoll, _super);
+    function DeltaLongPoll(connection, cursor, timeout, params) {
+        if (params === void 0) { params = {}; }
+        var _this = _super.call(this, connection, cursor, params) || this;
+        params['timeout'] = timeout;
+        _this.params = params;
+        _this.path = '/delta/longpoll';
+        _this.modelClass = deltas_1.Deltas;
+        return _this;
+    }
+    DeltaLongPoll.prototype.onDataReceived = function () {
+        // For streaming we restart the connection on every data received in order
+        // to keep the connection alive. For long polling this is not needed as the
+        // server terminates the connection when data is sent
+        return;
+    };
+    return DeltaLongPoll;
+}(DeltaStream));
+exports.DeltaLongPoll = DeltaLongPoll;

package/lib/models/delta.d.ts

@@ -1,12 +1,28 @@
 import NylasConnection from '../nylas-connection';
-import DeltaStream from './delta-stream';
-export declare type LatestCursor = {
+import { Attribute } from './attributes';
+import RestfulModel from './restful-model';
+export declare type DeltaParams = {
+    view?: string;
+    includeTypes?: string[];
+    excludeTypes?: string[];
+    expanded?: boolean;
+};
+export declare type DeltaProperties = {
+    id: string;
     cursor: string;
+    event: string;
+    object: string;
+    objectAttributes?: unknown;
 };
-export default class Delta {
+export default class Delta extends RestfulModel implements DeltaProperties {
+    id: string;
+    cursor: string;
+    event: string;
+    object: string;
     connection: NylasConnection;
+    objectAttributes?: RestfulModel;
     static streamingTimeoutMs: number;
-    constructor(connection: NylasConnection);
-    latestCursor(callback: (error: Error | null, cursor: string | null) => void): Promise<string>;
-    startStream(cursor: string, params?: Record<string, unknown>): Promise<DeltaStream>;
+    static attributes: Record<string, Attribute>;
+    constructor(connection: NylasConnection, props?: DeltaProperties);
+    fromJSON(json: Record<string, unknown>): this;
 }

package/lib/models/delta.js

@@ -1,90 +1,88 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var nylas_connection_1 = __importDefault(require("../nylas-connection"));
-var delta_stream_1 = __importDefault(require("./delta-stream"));
-var Delta = /** @class */ (function () {
-    function Delta(connection) {
-        this.connection = connection;
-        if (!(this.connection instanceof nylas_connection_1.default)) {
-            throw new Error('Connection object not provided');
+var attributes_1 = __importDefault(require("./attributes"));
+var restful_model_1 = __importDefault(require("./restful-model"));
+var contact_1 = __importDefault(require("./contact"));
+var file_1 = __importDefault(require("./file"));
+var message_1 = __importDefault(require("./message"));
+var draft_1 = __importDefault(require("./draft"));
+var thread_1 = __importDefault(require("./thread"));
+var event_1 = __importDefault(require("./event"));
+var folder_1 = __importStar(require("./folder"));
+var DeltaClassMap = Object.freeze({
+    contact: contact_1.default,
+    file: file_1.default,
+    message: message_1.default,
+    draft: draft_1.default,
+    thread: thread_1.default,
+    event: event_1.default,
+    folder: folder_1.default,
+    label: folder_1.Label,
+});
+var Delta = /** @class */ (function (_super) {
+    __extends(Delta, _super);
+    function Delta(connection, props) {
+        var _this = _super.call(this, connection) || this;
+        _this.id = '';
+        _this.cursor = '';
+        _this.event = '';
+        _this.object = '';
+        _this.connection = connection;
+        _this.initAttributes(props);
+        if (_this.objectAttributes && DeltaClassMap[_this.object]) {
+            _this.objectAttributes = new DeltaClassMap[_this.object](connection, _this.objectAttributes);
         }
+        return _this;
     }
-    Delta.prototype.latestCursor = function (callback) {
-        var reqOpts = {
-            method: 'POST',
-            path: '/delta/latest_cursor',
-        };
-        return this.connection
-            .request(reqOpts)
-            .then(function (response) {
-            if (callback) {
-                callback(null, response.cursor);
-            }
-            return Promise.resolve(response.cursor);
-        })
-            .catch(function (err) {
-            if (callback) {
-                callback(err, null);
-            }
-            return Promise.reject(err);
-        });
-    };
-    Delta.prototype.startStream = function (cursor, params) {
-        if (params === void 0) { params = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var stream;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        stream = new delta_stream_1.default(this.connection, cursor, params);
-                        return [4 /*yield*/, stream.open()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, stream];
-                }
-            });
-        });
+    Delta.prototype.fromJSON = function (json) {
+        _super.prototype.fromJSON.call(this, json);
+        if (this.objectAttributes && DeltaClassMap[this.object]) {
+            this.objectAttributes = new DeltaClassMap[this.object](this.connection).fromJSON(this.objectAttributes);
+        }
+        return this;
     };
     Delta.streamingTimeoutMs = 15000;
+    Delta.attributes = {
+        id: attributes_1.default.String({
+            modelKey: 'id',
+        }),
+        cursor: attributes_1.default.String({
+            modelKey: 'cursor',
+        }),
+        event: attributes_1.default.String({
+            modelKey: 'event',
+        }),
+        object: attributes_1.default.String({
+            modelKey: 'object',
+        }),
+        objectAttributes: attributes_1.default.Object({
+            modelKey: 'objectAttributes',
+            jsonKey: 'attributes',
+        }),
+    };
     return Delta;
-}());
+}(restful_model_1.default));
 exports.default = Delta;

package/lib/models/deltas.d.ts

@@ -0,0 +1,17 @@
+import Model from './model';
+import NylasConnection from '../nylas-connection';
+import { Attribute } from './attributes';
+import Delta, { DeltaProperties } from './delta';
+export declare type DeltasProperties = {
+    cursorStart: string;
+    cursorEnd: string;
+    deltas: DeltaProperties[];
+};
+export declare class Deltas extends Model implements DeltasProperties {
+    cursorStart: string;
+    cursorEnd: string;
+    deltas: Delta[];
+    connection: NylasConnection;
+    static attributes: Record<string, Attribute>;
+    constructor(connection: NylasConnection, props?: DeltasProperties);
+}