nylas 5.8.0

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

@@ -0,0 +1,76 @@
+import Calendar from './calendar';
+import NylasConnection from '../nylas-connection';
+import RestfulModelCollection from './restful-model-collection';
+export default class CalendarRestfulModelCollection extends RestfulModelCollection<Calendar> {
+    connection: NylasConnection;
+    modelClass: typeof Calendar;
+    constructor(connection: NylasConnection);
+    freeBusy(options: {
+        start_time?: string;
+        startTime?: string;
+        end_time?: string;
+        endTime?: string;
+        emails: string[];
+    }, callback?: (error: Error | null, data?: {
+        [key: string]: any;
+    }) => void): Promise<any>;
+    availability(options: {
+        emails: string[];
+        duration: number;
+        interval: number;
+        start_time?: string;
+        startTime?: string;
+        end_time?: string;
+        endTime?: string;
+        free_busy?: Array<{
+            emails: string;
+            object: string;
+            time_slots: Array<{
+                object: string;
+                status: string;
+                start_time: string;
+                end_time: string;
+            }>;
+        }>;
+        open_hours: Array<{
+            emails: string[];
+            days: string[];
+            timezone: string;
+            start: string;
+            end: string;
+            object_type: string;
+        }>;
+    }, callback?: (error: Error | null, data?: {
+        [key: string]: any;
+    }) => void): Promise<any>;
+    consecutiveAvailability(options: {
+        emails: Array<string[]>;
+        duration: number;
+        interval: number;
+        start_time?: number;
+        startTime?: number;
+        end_time?: number;
+        endTime?: number;
+        buffer?: number;
+        free_busy?: Array<{
+            email: string;
+            object: string;
+            time_slots: Array<{
+                object: string;
+                status: string;
+                start_time: number;
+                end_time: number;
+            }>;
+        }>;
+        open_hours: Array<{
+            emails: string[];
+            days: number[];
+            timezone: string;
+            start: string;
+            end: string;
+            object_type: string;
+        }>;
+    }, callback?: (error: Error | null, data?: {
+        [key: string]: any;
+    }) => void): Promise<any>;
+}

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

@@ -0,0 +1,128 @@
+"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 calendar_1 = __importDefault(require("./calendar"));
+var restful_model_collection_1 = __importDefault(require("./restful-model-collection"));
+var CalendarRestfulModelCollection = /** @class */ (function (_super) {
+    __extends(CalendarRestfulModelCollection, _super);
+    function CalendarRestfulModelCollection(connection) {
+        var _this = _super.call(this, calendar_1.default, connection) || this;
+        _this.connection = connection;
+        _this.modelClass = calendar_1.default;
+        return _this;
+    }
+    CalendarRestfulModelCollection.prototype.freeBusy = function (options, callback) {
+        return this.connection
+            .request({
+            method: 'POST',
+            path: "/calendars/free-busy",
+            body: {
+                start_time: options.startTime || options.start_time,
+                end_time: options.endTime || options.end_time,
+                emails: options.emails,
+            },
+        })
+            .then(function (json) {
+            if (callback) {
+                callback(null, json);
+            }
+            return Promise.resolve(json);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    CalendarRestfulModelCollection.prototype.availability = function (options, callback) {
+        return this.connection
+            .request({
+            method: 'POST',
+            path: "/calendars/availability",
+            body: {
+                emails: options.emails,
+                duration_minutes: options.duration,
+                interval_minutes: options.interval,
+                start_time: options.startTime || options.start_time,
+                end_time: options.endTime || options.end_time,
+                free_busy: options.free_busy || [],
+                open_hours: options.open_hours,
+            },
+        })
+            .then(function (json) {
+            if (callback) {
+                callback(null, json);
+            }
+            return Promise.resolve(json);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    CalendarRestfulModelCollection.prototype.consecutiveAvailability = function (options, callback) {
+        var freeBusyEmails = options.free_busy
+            ? options.free_busy.map(function (freeBusy) { return freeBusy.email; })
+            : [];
+        for (var _i = 0, _a = options.open_hours; _i < _a.length; _i++) {
+            var openHour = _a[_i];
+            var _loop_1 = function (email) {
+                if (!options.emails.some(function (row) { return row.includes(email); }) &&
+                    !freeBusyEmails.includes(email)) {
+                    throw new Error('Open Hours cannot contain an email not present in the main email list or the free busy email list.');
+                }
+            };
+            for (var _b = 0, _c = openHour.emails; _b < _c.length; _b++) {
+                var email = _c[_b];
+                _loop_1(email);
+            }
+        }
+        return this.connection
+            .request({
+            method: 'POST',
+            path: "/calendars/availability/consecutive",
+            body: {
+                emails: options.emails,
+                duration_minutes: options.duration,
+                interval_minutes: options.interval,
+                start_time: options.startTime || options.start_time,
+                end_time: options.endTime || options.end_time,
+                buffer: options.buffer,
+                free_busy: options.free_busy || [],
+                open_hours: options.open_hours,
+            },
+        })
+            .then(function (json) {
+            if (callback) {
+                callback(null, json);
+            }
+            return Promise.resolve(json);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    return CalendarRestfulModelCollection;
+}(restful_model_collection_1.default));
+exports.default = CalendarRestfulModelCollection;

package/lib/models/calendar.d.ts

@@ -0,0 +1,19 @@
+import RestfulModel, { SaveCallback } from './restful-model';
+import { GetCallback } from './restful-model-collection';
+export default class Calendar extends RestfulModel {
+    name?: string;
+    description?: string;
+    readOnly?: boolean;
+    location?: string;
+    timezone?: string;
+    isPrimary?: boolean;
+    jobStatusId?: string;
+    save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
+    saveRequestBody(): {
+        name: any;
+        description: any;
+        location: any;
+        timezone: any;
+    };
+    getJobStatus(callback?: GetCallback): Promise<import("./job-status").default>;
+}

package/lib/models/calendar.js

@@ -0,0 +1,81 @@
+"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 attributes_1 = __importDefault(require("./attributes"));
+var Calendar = /** @class */ (function (_super) {
+    __extends(Calendar, _super);
+    function Calendar() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Calendar.prototype.save = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this._save(params, callback);
+    };
+    Calendar.prototype.saveRequestBody = function () {
+        var calendarJSON = _super.prototype.saveRequestBody.call(this);
+        return {
+            name: calendarJSON.name,
+            description: calendarJSON.description,
+            location: calendarJSON.location,
+            timezone: calendarJSON.timezone,
+        };
+    };
+    Calendar.prototype.getJobStatus = function (callback) {
+        if (typeof this.jobStatusId === 'undefined') {
+            var err = new Error('jobStatusId must be defined');
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        }
+        return this.connection.jobStatuses.find(this.jobStatusId, callback);
+    };
+    return Calendar;
+}(restful_model_1.default));
+exports.default = Calendar;
+Calendar.collectionName = 'calendars';
+Calendar.attributes = __assign(__assign({}, restful_model_1.default.attributes), { name: attributes_1.default.String({
+        modelKey: 'name',
+    }), description: attributes_1.default.String({
+        modelKey: 'description',
+    }), readOnly: attributes_1.default.Boolean({
+        modelKey: 'readOnly',
+        jsonKey: 'read_only',
+    }), location: attributes_1.default.String({
+        modelKey: 'location',
+    }), timezone: attributes_1.default.String({
+        modelKey: 'timezone',
+    }), isPrimary: attributes_1.default.Boolean({
+        modelKey: 'isPrimary',
+        jsonKey: 'is_primary',
+    }), jobStatusId: attributes_1.default.String({
+        modelKey: 'jobStatusId',
+        jsonKey: 'job_status_id',
+    }) });

package/lib/models/connect.d.ts

@@ -0,0 +1,12 @@
+import NylasConnection from '../nylas-connection';
+export default class Connect {
+    connection: NylasConnection;
+    clientId: string;
+    clientSecret: string;
+    constructor(connection: NylasConnection, clientId: string, clientSecret: string);
+    authorize(options?: {
+        [key: string]: any;
+    }): Promise<any>;
+    token(code: string): Promise<any>;
+    newAccount(): void;
+}

package/lib/models/connect.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Connect = /** @class */ (function () {
+    function Connect(connection, clientId, clientSecret) {
+        this.connection = connection;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+    }
+    Connect.prototype.authorize = function (options) {
+        if (options === void 0) { options = {}; }
+        // https://docs.nylas.com/reference#connectauthorize
+        if (!this.clientId) {
+            throw new Error('connect.authorize() cannot be called until you provide a clientId via Nylas.config()');
+        }
+        return this.connection.request({
+            method: 'POST',
+            path: '/connect/authorize',
+            body: {
+                client_id: this.clientId,
+                name: options.name,
+                email_address: options.email_address,
+                provider: options.provider,
+                settings: options.settings,
+                scopes: options.scopes,
+            },
+        });
+    };
+    Connect.prototype.token = function (code) {
+        // https://docs.nylas.com/reference#connecttoken
+        if (!this.clientId) {
+            throw new Error('connect.token() cannot be called until you provide a clientId via Nylas.config()');
+        }
+        if (!this.clientSecret) {
+            throw new Error('connect.token() cannot be called until you provide a clientSecret via Nylas.config()');
+        }
+        return this.connection.request({
+            method: 'POST',
+            path: '/connect/token',
+            body: {
+                client_id: this.clientId,
+                client_secret: this.clientSecret,
+                code: code,
+            },
+        });
+    };
+    Connect.prototype.newAccount = function () {
+        // this.authorize() -> this.token()
+    };
+    return Connect;
+}());
+exports.default = Connect;

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

@@ -0,0 +1,11 @@
+import { Contact } from './contact';
+import NylasConnection from '../nylas-connection';
+import RestfulModelCollection from './restful-model-collection';
+export default class ContactRestfulModelCollection extends RestfulModelCollection<Contact> {
+    connection: NylasConnection;
+    modelClass: typeof Contact;
+    constructor(connection: NylasConnection);
+    groups(callback?: (error: Error | null, data?: {
+        [key: string]: any;
+    }) => void): Promise<any>;
+}

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

@@ -0,0 +1,54 @@
+"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 contact_1 = require("./contact");
+var restful_model_collection_1 = __importDefault(require("./restful-model-collection"));
+var ContactRestfulModelCollection = /** @class */ (function (_super) {
+    __extends(ContactRestfulModelCollection, _super);
+    function ContactRestfulModelCollection(connection) {
+        var _this = _super.call(this, contact_1.Contact, connection) || this;
+        _this.connection = connection;
+        _this.modelClass = contact_1.Contact;
+        return _this;
+    }
+    ContactRestfulModelCollection.prototype.groups = function (callback) {
+        var _this = this;
+        return this.connection
+            .request({
+            method: 'GET',
+            path: "/contacts/groups",
+        })
+            .then(function (json) {
+            var groups = json.map(function (group) {
+                return new contact_1.Group(_this.connection, group);
+            });
+            if (callback) {
+                callback(null, groups);
+            }
+            return Promise.resolve(groups);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    return ContactRestfulModelCollection;
+}(restful_model_collection_1.default));
+exports.default = ContactRestfulModelCollection;

package/lib/models/contact.d.ts

@@ -0,0 +1,75 @@
+import RestfulModel, { SaveCallback } from './restful-model';
+export declare class EmailAddress extends RestfulModel {
+    type?: string;
+    email?: string;
+    toJSON(): {
+        type: string | undefined;
+        email: string | undefined;
+    };
+}
+declare class IMAddress extends RestfulModel {
+    type?: string;
+    imAddress?: string;
+    toJSON(): {
+        type: string | undefined;
+        im_address: string | undefined;
+    };
+}
+declare class PhysicalAddress extends RestfulModel {
+    type?: string;
+    format?: string;
+    address?: string;
+    streetAddress?: string;
+    city?: string;
+    postalCode?: string;
+    state?: string;
+    country?: string;
+    toJSON(): {
+        [key: string]: any;
+    };
+}
+export declare class PhoneNumber extends RestfulModel {
+    type?: string;
+    number?: string;
+    toJSON(): {
+        type: string | undefined;
+        number: string | undefined;
+    };
+}
+export declare class WebPage extends RestfulModel {
+    type?: string;
+    url?: string;
+    toJSON(): {
+        type: string | undefined;
+        url: string | undefined;
+    };
+}
+export declare class Group extends RestfulModel {
+    type?: string;
+    path?: string;
+}
+export declare class Contact extends RestfulModel {
+    givenName?: string;
+    middleName?: string;
+    surname?: string;
+    suffix?: string;
+    nickname?: string;
+    birthday?: string;
+    companyName?: string;
+    jobTitle?: string;
+    officeLocation?: string;
+    notes?: string;
+    pictureUrl?: string;
+    emailAddresses?: EmailAddress[];
+    imAddresses?: IMAddress[];
+    physicalAddresses?: PhysicalAddress[];
+    phoneNumbers?: PhoneNumber[];
+    webPages?: WebPage[];
+    groups?: Group[];
+    source?: string;
+    save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
+    getPicture(params?: {
+        [key: string]: any;
+    }, callback?: (error: Error | null, result?: any) => void): Promise<any>;
+}
+export {};