nylas 5.8.0

package/lib/models/neural-signature-extraction.d.ts

@@ -0,0 +1,7 @@
+import NeuralSignatureContact from './neural-signature-contact';
+import Message from './message';
+export default class NeuralSignatureExtraction extends Message {
+    signature?: string;
+    modelVersion?: string;
+    contacts?: NeuralSignatureContact;
+}

package/lib/models/neural-signature-extraction.js

@@ -0,0 +1,50 @@
+"use strict";
+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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var neural_signature_contact_1 = __importDefault(require("./neural-signature-contact"));
+var attributes_1 = __importDefault(require("./attributes"));
+var message_1 = __importDefault(require("./message"));
+var NeuralSignatureExtraction = /** @class */ (function (_super) {
+    __extends(NeuralSignatureExtraction, _super);
+    function NeuralSignatureExtraction() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return NeuralSignatureExtraction;
+}(message_1.default));
+exports.default = NeuralSignatureExtraction;
+NeuralSignatureExtraction.collectionName = 'signature';
+NeuralSignatureExtraction.attributes = __assign(__assign({}, message_1.default.attributes), { signature: attributes_1.default.String({
+        modelKey: 'signature',
+    }), modelVersion: attributes_1.default.String({
+        modelKey: 'modelVersion',
+        jsonKey: 'model_version',
+    }), contacts: attributes_1.default.Object({
+        modelKey: 'contacts',
+        itemClass: neural_signature_contact_1.default,
+    }) });

package/lib/models/neural.d.ts

@@ -0,0 +1,22 @@
+import RestfulModel from './restful-model';
+import NeuralSentimentAnalysis from './neural-sentiment-analysis';
+import NeuralSignatureExtraction from './neural-signature-extraction';
+import NeuralOcr from './neural-ocr';
+import NeuralCategorizer from './neural-categorizer';
+import NeuralCleanConversation from './neural-clean-conversation';
+export declare type NeuralMessageOptions = {
+    ignore_links?: boolean;
+    ignore_images?: boolean;
+    ignore_tables?: boolean;
+    remove_conclusion_phrases?: boolean;
+    images_as_markdowns?: boolean;
+};
+export default class Neural extends RestfulModel {
+    sentimentAnalysisMessage(messageIds: string[]): Promise<NeuralSentimentAnalysis[]>;
+    sentimentAnalysisText(text: string): Promise<NeuralSentimentAnalysis>;
+    extractSignature(messageIds: string[], parseContact?: boolean, options?: NeuralMessageOptions): Promise<NeuralSignatureExtraction[]>;
+    ocrRequest(fileId: string, pages?: number[]): Promise<NeuralOcr>;
+    categorize(messageIds: string[]): Promise<NeuralCategorizer[]>;
+    cleanConversation(messageIds: string[], options?: NeuralMessageOptions): Promise<NeuralCleanConversation[]>;
+    _request(path?: string, body?: object): Promise<any>;
+}

package/lib/models/neural.js

@@ -0,0 +1,124 @@
+"use strict";
+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 __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 __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"));
+var neural_sentiment_analysis_1 = __importDefault(require("./neural-sentiment-analysis"));
+var neural_signature_extraction_1 = __importDefault(require("./neural-signature-extraction"));
+var neural_ocr_1 = __importDefault(require("./neural-ocr"));
+var neural_categorizer_1 = __importDefault(require("./neural-categorizer"));
+var neural_clean_conversation_1 = __importDefault(require("./neural-clean-conversation"));
+var Neural = /** @class */ (function (_super) {
+    __extends(Neural, _super);
+    function Neural() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Neural.prototype.sentimentAnalysisMessage = function (messageIds) {
+        var _this = this;
+        var body = { message_id: messageIds };
+        var path = 'sentiment';
+        return this._request(path, body).then(function (jsonArray) {
+            return jsonArray.map(function (json) {
+                return new neural_sentiment_analysis_1.default(_this.connection, json);
+            });
+        });
+    };
+    Neural.prototype.sentimentAnalysisText = function (text) {
+        var _this = this;
+        var body = { text: text };
+        var path = 'sentiment';
+        return this._request(path, body).then(function (json) {
+            return new neural_sentiment_analysis_1.default(_this.connection, json);
+        });
+    };
+    Neural.prototype.extractSignature = function (messageIds, parseContact, options) {
+        var _this = this;
+        var body = { message_id: messageIds };
+        var path = 'signature';
+        if (options) {
+            body = __assign(__assign({}, body), options);
+        }
+        if (parseContact) {
+            body['parse_contact'] = parseContact;
+        }
+        return this._request(path, body).then(function (jsonArray) {
+            return jsonArray.map(function (json) {
+                return new neural_signature_extraction_1.default(_this.connection, json);
+            });
+        });
+    };
+    Neural.prototype.ocrRequest = function (fileId, pages) {
+        var _this = this;
+        var body = { file_id: fileId };
+        var path = 'ocr';
+        if (pages) {
+            body['pages'] = pages;
+        }
+        return this._request(path, body).then(function (json) {
+            return new neural_ocr_1.default(_this.connection, json);
+        });
+    };
+    Neural.prototype.categorize = function (messageIds) {
+        var _this = this;
+        var body = { message_id: messageIds };
+        var path = 'categorize';
+        return this._request(path, body).then(function (jsonArray) {
+            return jsonArray.map(function (json) {
+                return new neural_categorizer_1.default(_this.connection, json);
+            });
+        });
+    };
+    Neural.prototype.cleanConversation = function (messageIds, options) {
+        var _this = this;
+        var body = { message_id: messageIds };
+        var path = 'conversation';
+        if (options) {
+            body = __assign(__assign({}, body), options);
+        }
+        return this._request(path, body).then(function (jsonArray) {
+            return jsonArray.map(function (json) {
+                return new neural_clean_conversation_1.default(_this.connection, json);
+            });
+        });
+    };
+    Neural.prototype._request = function (path, body) {
+        if (!path) {
+            path = this.constructor.collectionName;
+        }
+        return this.connection.request({
+            method: 'PUT',
+            path: "/neural/" + path,
+            body: body,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    };
+    return Neural;
+}(restful_model_1.default));
+exports.default = Neural;

package/lib/models/nylas-api-error.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Extended Error class for errors returned from the Nylas API
+ *
+ * Properties:
+ * name - The description of the HTTP status code
+ * message - The error message returned from the Nylas API payload
+ * statusCode - The status code returned from the API call
+ * type - The type of error returned from the Nylas API payload
+ * stack - The Error stacktrace
+ * missingFields (optional) - The fields that were missing in the call returned from the Nylas API payload
+ * serverError (optional) - The error returned by the provider returned from the Nylas API payload
+ */
+export default class NylasApiError extends Error {
+    statusCode: number;
+    type: string;
+    missingFields?: string[];
+    serverError?: string;
+    /**
+     * Mapping of HTTP status codes to error descriptions
+     *
+     * For more details on what each status code means head to
+     * https://developer.nylas.com/docs/developer-tools/api/errors/
+     */
+    errorMapping: {
+        [statusCode: number]: string;
+    };
+    constructor(statusCode: number, type: string, message: string);
+}

package/lib/models/nylas-api-error.js

@@ -0,0 +1,61 @@
+"use strict";
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Extended Error class for errors returned from the Nylas API
+ *
+ * Properties:
+ * name - The description of the HTTP status code
+ * message - The error message returned from the Nylas API payload
+ * statusCode - The status code returned from the API call
+ * type - The type of error returned from the Nylas API payload
+ * stack - The Error stacktrace
+ * missingFields (optional) - The fields that were missing in the call returned from the Nylas API payload
+ * serverError (optional) - The error returned by the provider returned from the Nylas API payload
+ */
+var NylasApiError = /** @class */ (function (_super) {
+    __extends(NylasApiError, _super);
+    function NylasApiError(statusCode, type, message) {
+        var _this = _super.call(this, message) || this;
+        /**
+         * Mapping of HTTP status codes to error descriptions
+         *
+         * For more details on what each status code means head to
+         * https://developer.nylas.com/docs/developer-tools/api/errors/
+         */
+        _this.errorMapping = {
+            400: 'Bad Request',
+            401: 'Unauthorized',
+            402: 'Request Failed or Payment Required',
+            403: 'Forbidden',
+            404: 'Not Found',
+            405: 'Method Not Allowed',
+            410: 'Gone',
+            418: "I'm a Teapot",
+            422: 'Sending Error',
+            429: 'Too Many Requests',
+            500: 'Server Error',
+            502: 'Server Error',
+            503: 'Server Error',
+            504: 'Server Error',
+        };
+        _this.statusCode = statusCode;
+        _this.name = _this.errorMapping[statusCode];
+        _this.type = type;
+        return _this;
+    }
+    return NylasApiError;
+}(Error));
+exports.default = NylasApiError;

package/lib/models/resource.d.ts

@@ -0,0 +1,9 @@
+import RestfulModel from './restful-model';
+export default class Resource extends RestfulModel {
+    email?: string;
+    name?: string;
+    capacity?: string;
+    building?: string;
+    floorName?: string;
+    floorNumber?: string;
+}

package/lib/models/resource.js

@@ -0,0 +1,59 @@
+"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var restful_model_1 = __importDefault(require("./restful-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var Resource = /** @class */ (function (_super) {
+    __extends(Resource, _super);
+    function Resource() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Resource;
+}(restful_model_1.default));
+exports.default = Resource;
+Resource.collectionName = 'resources';
+Resource.attributes = {
+    object: attributes_1.default.String({
+        modelKey: 'object',
+        readOnly: true,
+    }),
+    email: attributes_1.default.String({
+        modelKey: 'email',
+    }),
+    name: attributes_1.default.String({
+        modelKey: 'name',
+    }),
+    capacity: attributes_1.default.String({
+        modelKey: 'capacity',
+        readOnly: true,
+    }),
+    building: attributes_1.default.String({
+        modelKey: 'building',
+        readOnly: true,
+    }),
+    floorName: attributes_1.default.String({
+        modelKey: 'floorName',
+        jsonKey: 'floor_name',
+        readOnly: true,
+    }),
+    floorNumber: attributes_1.default.String({
+        modelKey: 'floorNumber',
+        jsonKey: 'floor_number',
+        readOnly: true,
+    }),
+};

package/lib/models/restful-model-collection.d.ts

@@ -0,0 +1,59 @@
+import NylasConnection from '../nylas-connection';
+import RestfulModel from './restful-model';
+export declare type GetCallback = (error: Error | null, result?: RestfulModel) => void;
+export default class RestfulModelCollection<T extends RestfulModel> {
+    connection: NylasConnection;
+    modelClass: typeof RestfulModel;
+    constructor(modelClass: typeof RestfulModel, connection: NylasConnection);
+    forEach(params: {
+        [key: string]: any;
+    } | undefined, eachCallback: (item: T) => void, completeCallback?: (err?: Error | null | undefined) => void): Promise<never> | undefined;
+    count(params?: {
+        [key: string]: any;
+    }, callback?: (err: Error | null, num?: number) => void): Promise<any>;
+    first(params?: {
+        [key: string]: any;
+    }, callback?: (error: Error | null, model?: T) => void): Promise<T>;
+    list(params?: {
+        [key: string]: any;
+    }, callback?: (error: Error | null, obj?: T[]) => void): Promise<void | T[]>;
+    find(id: string, paramsArg?: {
+        [key: string]: any;
+    } | GetCallback | null, callbackArg?: GetCallback | {
+        [key: string]: any;
+    } | null): Promise<T>;
+    search(query: string, params?: {
+        [key: string]: any;
+    }, callback?: (error: Error | null) => void): Promise<void | T[]>;
+    delete(itemOrId: T | string, params?: {
+        [key: string]: any;
+    }, callback?: (error: Error | null) => void): Promise<any>;
+    deleteItem(options: {
+        [key: string]: any;
+    }, callbackArg?: (error: Error | null) => void): Promise<any>;
+    build(args: {
+        [key: string]: any;
+    }): T;
+    path(): string;
+    _range({ params, offset, limit, callback, path, }: {
+        params?: {
+            [key: string]: any;
+        };
+        offset?: number;
+        limit?: number;
+        callback?: (error: Error | null, results?: T[]) => void;
+        path?: string;
+    }): Promise<void | T[]>;
+    _getItems(params: {
+        [key: string]: any;
+    }, offset: number, limit: number, path?: string): Promise<T[]>;
+    _createModel(json: {
+        [key: string]: any;
+    }): T;
+    _getModel(id: string, params?: {
+        [key: string]: any;
+    }): Promise<T>;
+    _getModelCollection(params: {
+        [key: string]: any;
+    }, offset: number, limit: number, path: string): Promise<T[]>;
+}

package/lib/models/restful-model-collection.js

@@ -0,0 +1,325 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var message_1 = __importDefault(require("./message"));
+var nylas_connection_1 = __importDefault(require("../nylas-connection"));
+var thread_1 = __importDefault(require("./thread"));
+var REQUEST_CHUNK_SIZE = 100;
+var RestfulModelCollection = /** @class */ (function () {
+    function RestfulModelCollection(modelClass, connection) {
+        this.modelClass = modelClass;
+        this.connection = connection;
+        if (!(this.connection instanceof nylas_connection_1.default)) {
+            throw new Error('Connection object not provided');
+        }
+        if (!this.modelClass) {
+            throw new Error('Model class not provided');
+        }
+    }
+    RestfulModelCollection.prototype.forEach = function (params, eachCallback, completeCallback) {
+        var _this = this;
+        if (params === void 0) { params = {}; }
+        if (params.view == 'count') {
+            var err = new Error('forEach() cannot be called with the count view');
+            if (completeCallback) {
+                completeCallback(err);
+            }
+            return Promise.reject(err);
+        }
+        var offset = 0;
+        var iteratee = function () {
+            return _this._getItems(params, offset, REQUEST_CHUNK_SIZE).then(function (items) {
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var item = items_1[_i];
+                    eachCallback(item);
+                }
+                offset += items.length;
+                var finished = items.length < REQUEST_CHUNK_SIZE;
+                if (finished === false) {
+                    return iteratee();
+                }
+            });
+        };
+        iteratee().then(function () {
+            if (completeCallback) {
+                completeCallback();
+            }
+        }, function (err) {
+            if (completeCallback) {
+                return completeCallback(err);
+            }
+        });
+    };
+    RestfulModelCollection.prototype.count = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this.connection
+            .request({
+            method: 'GET',
+            path: this.path(),
+            qs: __assign({ view: 'count' }, params),
+        })
+            .then(function (json) {
+            if (callback) {
+                callback(null, json.count);
+            }
+            return Promise.resolve(json.count);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    RestfulModelCollection.prototype.first = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        if (params.view == 'count') {
+            var err = new Error('first() cannot be called with the count view');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        return this._getItems(params, 0, 1)
+            .then(function (items) {
+            if (callback) {
+                callback(null, items[0]);
+            }
+            return Promise.resolve(items[0]);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    RestfulModelCollection.prototype.list = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        if (params.view == 'count') {
+            var err = new Error('list() cannot be called with the count view');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        var limit = params.limit || Infinity;
+        var offset = params.offset;
+        return this._range({ params: params, offset: offset, limit: limit, callback: callback });
+    };
+    RestfulModelCollection.prototype.find = function (id, paramsArg, callbackArg) {
+        // callback used to be the second argument, and params was the third
+        var callback;
+        if (typeof callbackArg === 'function') {
+            callback = callbackArg;
+        }
+        else if (typeof paramsArg === 'function') {
+            callback = paramsArg;
+        }
+        var params = {};
+        if (paramsArg && typeof paramsArg === 'object') {
+            params = paramsArg;
+        }
+        else if (callbackArg && typeof callbackArg === 'object') {
+            params = callbackArg;
+        }
+        if (!id) {
+            var err = new Error('find() must be called with an item id');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        if (params.view == 'count' || params.view == 'ids') {
+            var err = new Error('find() cannot be called with the count or ids view');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        return this._getModel(id, params)
+            .then(function (model) {
+            if (callback) {
+                callback(null, model);
+            }
+            return Promise.resolve(model);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    RestfulModelCollection.prototype.search = function (query, params, callback) {
+        if (params === void 0) { params = {}; }
+        if (this.modelClass != message_1.default && this.modelClass != thread_1.default) {
+            var err = new Error('search() can only be called for messages and threads');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        if (!query) {
+            var err = new Error('search() requires a query string');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        params.q = query;
+        var limit = params.limit || 40;
+        var offset = params.offset;
+        var path = this.path() + "/search";
+        return this._range({ params: params, offset: offset, limit: limit, path: path });
+    };
+    RestfulModelCollection.prototype.delete = function (itemOrId, params, callback) {
+        if (params === void 0) { params = {}; }
+        if (!itemOrId) {
+            var err = new Error('delete() requires an item or an id');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        if (typeof params === 'function') {
+            callback = params;
+            params = {};
+        }
+        var item = typeof itemOrId === 'string' ? this.build({ id: itemOrId }) : itemOrId;
+        var options = item.deleteRequestOptions(params);
+        options.item = item;
+        return this.deleteItem(options, callback);
+    };
+    RestfulModelCollection.prototype.deleteItem = function (options, callbackArg) {
+        var item = options.item;
+        // callback used to be in the options object
+        var callback = options.callback ? options.callback : callbackArg;
+        var body = options.hasOwnProperty('body')
+            ? options.body
+            : item.deleteRequestBody({});
+        var qs = options.hasOwnProperty('qs')
+            ? options.qs
+            : item.deleteRequestQueryString({});
+        return this.connection
+            .request({
+            method: 'DELETE',
+            qs: qs,
+            body: body,
+            path: this.path() + "/" + item.id,
+        })
+            .then(function (data) {
+            if (callback) {
+                callback(null, data);
+            }
+            return Promise.resolve(data);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    RestfulModelCollection.prototype.build = function (args) {
+        var model = this._createModel({});
+        for (var key in args) {
+            var val = args[key];
+            model[key] = val;
+        }
+        return model;
+    };
+    RestfulModelCollection.prototype.path = function () {
+        return "/" + this.modelClass.collectionName;
+    };
+    RestfulModelCollection.prototype._range = function (_a) {
+        var _this = this;
+        var _b = _a.params, params = _b === void 0 ? {} : _b, _c = _a.offset, offset = _c === void 0 ? 0 : _c, _d = _a.limit, limit = _d === void 0 ? 100 : _d, callback = _a.callback, path = _a.path;
+        var accumulated = [];
+        var iteratee = function () {
+            var chunkOffset = offset + accumulated.length;
+            var chunkLimit = Math.min(REQUEST_CHUNK_SIZE, limit - accumulated.length);
+            return _this._getItems(params, chunkOffset, chunkLimit, path).then(function (items) {
+                accumulated = accumulated.concat(items);
+                var finished = items.length < REQUEST_CHUNK_SIZE || accumulated.length >= limit;
+                if (finished === false) {
+                    return iteratee();
+                }
+            });
+        };
+        // do not return rejected promise when callback is provided
+        // to prevent unhandled rejection warning
+        return iteratee().then(function () {
+            if (callback) {
+                return callback(null, accumulated);
+            }
+            return accumulated;
+        }, function (err) {
+            if (callback) {
+                return callback(err);
+            }
+            throw err;
+        });
+    };
+    RestfulModelCollection.prototype._getItems = function (params, offset, limit, path) {
+        // Items can be either models or ids
+        if (!path) {
+            path = this.path();
+        }
+        if (params.view == 'ids') {
+            return this.connection.request({
+                method: 'GET',
+                path: path,
+                qs: __assign(__assign({}, params), { offset: offset, limit: limit }),
+            });
+        }
+        return this._getModelCollection(params, offset, limit, path);
+    };
+    RestfulModelCollection.prototype._createModel = function (json) {
+        return new this.modelClass(this.connection, json);
+    };
+    RestfulModelCollection.prototype._getModel = function (id, params) {
+        var _this = this;
+        if (params === void 0) { params = {}; }
+        return this.connection
+            .request({
+            method: 'GET',
+            path: this.path() + "/" + id,
+            qs: params,
+        })
+            .then(function (json) {
+            var model = _this._createModel(json);
+            return Promise.resolve(model);
+        });
+    };
+    RestfulModelCollection.prototype._getModelCollection = function (params, offset, limit, path) {
+        var _this = this;
+        return this.connection
+            .request({
+            method: 'GET',
+            path: path,
+            qs: __assign(__assign({}, params), { offset: offset, limit: limit }),
+        })
+            .then(function (jsonArray) {
+            var models = jsonArray.map(function (json) {
+                return _this._createModel(json);
+            });
+            return Promise.resolve(models);
+        });
+    };
+    return RestfulModelCollection;
+}());
+exports.default = RestfulModelCollection;