nylas 6.1.0 → 6.2.1

package/lib/models/deltas.js

@@ -0,0 +1,49 @@
+"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 model_1 = __importDefault(require("./model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var delta_1 = __importDefault(require("./delta"));
+var Deltas = /** @class */ (function (_super) {
+    __extends(Deltas, _super);
+    function Deltas(connection, props) {
+        var _this = _super.call(this) || this;
+        _this.cursorStart = '';
+        _this.cursorEnd = '';
+        _this.deltas = [];
+        _this.connection = connection;
+        _this.initAttributes(props);
+        return _this;
+    }
+    Deltas.attributes = {
+        cursorStart: attributes_1.default.String({
+            modelKey: 'cursorStart',
+            jsonKey: 'cursor_start',
+        }),
+        cursorEnd: attributes_1.default.String({
+            modelKey: 'cursorEnd',
+            jsonKey: 'cursor_end',
+        }),
+        deltas: attributes_1.default.Collection({
+            modelKey: 'deltas',
+            itemClass: delta_1.default,
+        }),
+    };
+    return Deltas;
+}(model_1.default));
+exports.Deltas = Deltas;

package/lib/models/draft.d.ts

@@ -12,9 +12,11 @@ export default class Draft extends Message implements DraftProperties {
     rawMime?: string;
     replyToMessageId?: string;
     version?: number;
+    fileIdsToAttach?: string[];
     static collectionName: string;
     static attributes: Record<string, Attribute>;
     constructor(connection: NylasConnection, props?: DraftProperties);
+    fileIds(): (string | undefined)[];
     toJSON(enforceReadOnly?: boolean): Record<string, any>;
     save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
     saveRequestBody(): Record<string, unknown>;

package/lib/models/draft.js

@@ -36,12 +36,19 @@ var Draft = /** @class */ (function (_super) {
         _this.initAttributes(props);
         return _this;
     }
+    Draft.prototype.fileIds = function () {
+        var fileIds = _super.prototype.fileIds.call(this);
+        if (this.fileIdsToAttach) {
+            fileIds = Array.from(new Set(fileIds.concat(this.fileIdsToAttach)));
+        }
+        return fileIds;
+    };
     Draft.prototype.toJSON = function (enforceReadOnly) {
         if (this.rawMime) {
             throw Error('toJSON() cannot be called for raw MIME drafts');
         }
         var json = _super.prototype.toJSON.call(this, enforceReadOnly);
-        json.file_ids = _super.prototype.fileIds.call(this);
+        json.file_ids = this.fileIds();
         return json;
     };
     Draft.prototype.save = function (params, callback) {

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

@@ -0,0 +1,20 @@
+import RestfulModelCollection from './restful-model-collection';
+import Message from './message';
+import NylasConnection from '../nylas-connection';
+export default class MessageRestfulModelCollection extends RestfulModelCollection<Message> {
+    connection: NylasConnection;
+    modelClass: typeof Message;
+    constructor(connection: NylasConnection);
+    /**
+     * Return Multiple Messages by a list of Message IDs.
+     * @param messageIds The list of message ids to find.
+     * @param options Additional options including: view, offset, limit, and callback
+     * @returns The list of messages.
+     */
+    findMultiple(messageIds: string[], options?: {
+        view?: string;
+        offset?: number;
+        limit?: number;
+        callback?: (error: Error | null, results?: Message[]) => void;
+    }): Promise<Message[]>;
+}

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

@@ -0,0 +1,58 @@
+"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_collection_1 = __importDefault(require("./restful-model-collection"));
+var message_1 = __importDefault(require("./message"));
+var MessageRestfulModelCollection = /** @class */ (function (_super) {
+    __extends(MessageRestfulModelCollection, _super);
+    function MessageRestfulModelCollection(connection) {
+        var _this = _super.call(this, message_1.default, connection) || this;
+        _this.connection = connection;
+        _this.modelClass = message_1.default;
+        return _this;
+    }
+    /**
+     * Return Multiple Messages by a list of Message IDs.
+     * @param messageIds The list of message ids to find.
+     * @param options Additional options including: view, offset, limit, and callback
+     * @returns The list of messages.
+     */
+    MessageRestfulModelCollection.prototype.findMultiple = function (messageIds, options) {
+        if (options && options.view) {
+            // view is a parameter, so move it into a params object
+            options.params = {
+                view: options.view,
+            };
+            delete options.view;
+        }
+        return this.range(__assign({ path: this.path() + "/" + messageIds.join() }, options));
+    };
+    return MessageRestfulModelCollection;
+}(restful_model_collection_1.default));
+exports.default = MessageRestfulModelCollection;

package/lib/models/outbox-job-status.d.ts

@@ -0,0 +1,21 @@
+import OutboxMessage, { OutboxMessageProperties } from './outbox-message';
+import Model from './model';
+import { Attribute } from './attributes';
+import NylasConnection from '../nylas-connection';
+export declare type OutboxJobStatusProperties = {
+    jobStatusId: string;
+    accountId: string;
+    status: string;
+    originalData?: OutboxMessageProperties;
+};
+export default class OutboxJobStatus extends Model implements OutboxJobStatusProperties {
+    jobStatusId: string;
+    status: string;
+    accountId: string;
+    originalData?: OutboxMessage;
+    private _connection?;
+    static attributes: Record<string, Attribute>;
+    constructor(props?: OutboxJobStatusProperties);
+    get connection(): NylasConnection | undefined;
+    fromJSON(json: Record<string, unknown>, connection?: NylasConnection): this;
+}

package/lib/models/outbox-job-status.js

@@ -0,0 +1,70 @@
+"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 outbox_message_1 = __importDefault(require("./outbox-message"));
+var model_1 = __importDefault(require("./model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var OutboxJobStatus = /** @class */ (function (_super) {
+    __extends(OutboxJobStatus, _super);
+    function OutboxJobStatus(props) {
+        var _this = _super.call(this) || this;
+        _this.jobStatusId = '';
+        _this.status = '';
+        _this.accountId = '';
+        _this.initAttributes(props);
+        return _this;
+    }
+    Object.defineProperty(OutboxJobStatus.prototype, "connection", {
+        get: function () {
+            return this._connection;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    OutboxJobStatus.prototype.fromJSON = function (json, connection) {
+        // Allow a connection object to be passed in to instantiate a Calendar sub object
+        if (connection) {
+            this._connection = connection;
+        }
+        return _super.prototype.fromJSON.call(this, json);
+    };
+    OutboxJobStatus.attributes = {
+        jobStatusId: attributes_1.default.String({
+            modelKey: 'jobStatusId',
+            jsonKey: 'job_status_id',
+            readOnly: true,
+        }),
+        status: attributes_1.default.String({
+            modelKey: 'status',
+            readOnly: true,
+        }),
+        accountId: attributes_1.default.String({
+            modelKey: 'accountId',
+            jsonKey: 'account_id',
+            readOnly: true,
+        }),
+        originalData: attributes_1.default.Object({
+            modelKey: 'originalData',
+            jsonKey: 'original_data',
+            itemClass: outbox_message_1.default,
+            readOnly: true,
+        }),
+    };
+    return OutboxJobStatus;
+}(model_1.default));
+exports.default = OutboxJobStatus;

package/lib/models/outbox-message.d.ts

@@ -0,0 +1,16 @@
+import Draft, { DraftProperties } from './draft';
+import { Attribute } from './attributes';
+import NylasConnection from '../nylas-connection';
+export declare type OutboxMessageProperties = DraftProperties & {
+    sendAt: Date;
+    retryLimitDatetime?: Date;
+    originalSendAt?: Date;
+};
+export default class OutboxMessage extends Draft implements OutboxMessageProperties {
+    sendAt: Date;
+    retryLimitDatetime?: Date;
+    originalSendAt?: Date;
+    static collectionName: string;
+    static attributes: Record<string, Attribute>;
+    constructor(connection: NylasConnection, props?: OutboxMessageProperties);
+}

package/lib/models/outbox-message.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 __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 draft_1 = __importDefault(require("./draft"));
+var attributes_1 = __importDefault(require("./attributes"));
+var OutboxMessage = /** @class */ (function (_super) {
+    __extends(OutboxMessage, _super);
+    function OutboxMessage(connection, props) {
+        var _this = _super.call(this, connection, props) || this;
+        _this.sendAt = new Date();
+        _this.initAttributes(props);
+        return _this;
+    }
+    OutboxMessage.collectionName = '/v2/outbox';
+    OutboxMessage.attributes = __assign(__assign({}, draft_1.default.attributes), { sendAt: attributes_1.default.DateTime({
+            modelKey: 'sendAt',
+            jsonKey: 'send_at',
+        }), retryLimitDatetime: attributes_1.default.DateTime({
+            modelKey: 'retryLimitDatetime',
+            jsonKey: 'retry_limit_datetime',
+        }), originalSendAt: attributes_1.default.DateTime({
+            modelKey: 'originalSendAt',
+            jsonKey: 'original_send_at',
+            readOnly: true,
+        }) });
+    return OutboxMessage;
+}(draft_1.default));
+exports.default = OutboxMessage;

package/lib/models/outbox.d.ts

@@ -0,0 +1,35 @@
+import NylasConnection from '../nylas-connection';
+import Draft, { SendCallback } from './draft';
+import OutboxJobStatus from './outbox-job-status';
+import Model from './model';
+import { Attribute } from './attributes';
+declare type SendParams = {
+    sendAt: Date | number;
+    retryLimitDatetime?: Date | number;
+    tracking?: Record<string, any>;
+    callback?: SendCallback;
+};
+declare type UpdateParams = {
+    updatedMessage?: Draft;
+    sendAt?: Date | number;
+    retryLimitDatetime?: Date | number;
+};
+export declare class SendGridVerifiedStatus extends Model {
+    domainVerified?: boolean;
+    senderVerified?: boolean;
+    static attributes: Record<string, Attribute>;
+}
+export default class Outbox {
+    connection: NylasConnection;
+    private path;
+    constructor(connection: NylasConnection);
+    send(draft: Draft, options: SendParams): Promise<OutboxJobStatus>;
+    update(jobStatusId: string, options: UpdateParams): Promise<OutboxJobStatus>;
+    delete(jobStatusId: string): Promise<void>;
+    sendGridVerificationStatus(): Promise<SendGridVerifiedStatus>;
+    deleteSendGridSubUser(email: string): Promise<void>;
+    private request;
+    private static validateAndFormatDateTime;
+    private static dateToEpoch;
+}
+export {};

package/lib/models/outbox.js

@@ -0,0 +1,158 @@
+"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 nylas_connection_1 = require("../nylas-connection");
+var outbox_job_status_1 = __importDefault(require("./outbox-job-status"));
+var model_1 = __importDefault(require("./model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var SendGridVerifiedStatus = /** @class */ (function (_super) {
+    __extends(SendGridVerifiedStatus, _super);
+    function SendGridVerifiedStatus() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SendGridVerifiedStatus.attributes = {
+        domainVerified: attributes_1.default.Boolean({
+            modelKey: 'domainVerified',
+            jsonKey: 'domain_verified',
+        }),
+        senderVerified: attributes_1.default.Boolean({
+            modelKey: 'senderVerified',
+            jsonKey: 'sender_verified',
+        }),
+    };
+    return SendGridVerifiedStatus;
+}(model_1.default));
+exports.SendGridVerifiedStatus = SendGridVerifiedStatus;
+var Outbox = /** @class */ (function () {
+    function Outbox(connection) {
+        this.path = '/v2/outbox';
+        this.connection = connection;
+    }
+    Outbox.prototype.send = function (draft, options) {
+        var _this = this;
+        var body = draft.saveRequestBody();
+        if (options.tracking) {
+            body['tracking'] = options.tracking;
+        }
+        var _a = Outbox.validateAndFormatDateTime(options.sendAt, options.retryLimitDatetime), sendAt = _a[0], retryLimitDatetime = _a[1];
+        body['send_at'] = sendAt;
+        body['retry_limit_datetime'] = retryLimitDatetime;
+        return this.request({
+            method: 'POST',
+            path: '',
+            body: body,
+        })
+            .then(function (json) {
+            var message = new outbox_job_status_1.default().fromJSON(json, _this.connection);
+            if (options.callback) {
+                options.callback(null, message);
+            }
+            return Promise.resolve(message);
+        })
+            .catch(function (err) {
+            if (options.callback) {
+                options.callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    Outbox.prototype.update = function (jobStatusId, options) {
+        var _this = this;
+        var body = {};
+        if (options.updatedMessage) {
+            body = options.updatedMessage.saveRequestBody();
+        }
+        var _a = Outbox.validateAndFormatDateTime(options.sendAt, options.retryLimitDatetime), sendAt = _a[0], retryLimitDatetime = _a[1];
+        body['send_at'] = sendAt;
+        body['retry_limit_datetime'] = retryLimitDatetime;
+        return this.request({
+            method: 'PATCH',
+            path: "/" + jobStatusId,
+            body: body,
+        }).then(function (json) {
+            var message = new outbox_job_status_1.default().fromJSON(json, _this.connection);
+            return Promise.resolve(message);
+        });
+    };
+    Outbox.prototype.delete = function (jobStatusId) {
+        return this.request({
+            method: 'DELETE',
+            path: "/" + jobStatusId,
+        });
+    };
+    Outbox.prototype.sendGridVerificationStatus = function () {
+        return this.request({
+            method: 'GET',
+            path: "/onboard/verified_status",
+        }).then(function (json) {
+            if (json.results) {
+                json = json.results;
+            }
+            var verifiedStatus = new SendGridVerifiedStatus().fromJSON(json);
+            return Promise.resolve(verifiedStatus);
+        });
+    };
+    Outbox.prototype.deleteSendGridSubUser = function (email) {
+        return this.request({
+            method: 'DELETE',
+            path: "/onboard/subuser",
+            body: { email: email },
+        });
+    };
+    Outbox.prototype.request = function (options) {
+        var header;
+        if (options.body) {
+            header = {
+                'Content-Type': 'application/json',
+            };
+        }
+        return this.connection.request({
+            method: options.method,
+            path: "" + this.path + options.path,
+            body: options.body,
+            headers: header,
+            authMethod: nylas_connection_1.AuthMethod.BEARER,
+        });
+    };
+    Outbox.validateAndFormatDateTime = function (sendAt, retryLimitDatetime) {
+        var sendAtEpoch = sendAt instanceof Date ? Outbox.dateToEpoch(sendAt) : sendAt;
+        var retryLimitDatetimeEpoch = retryLimitDatetime instanceof Date
+            ? Outbox.dateToEpoch(retryLimitDatetime)
+            : retryLimitDatetime;
+        if (sendAtEpoch && sendAtEpoch !== 0) {
+            if (sendAtEpoch < Outbox.dateToEpoch(new Date())) {
+                throw new Error('Cannot set message to be sent at a time before the current time.');
+            }
+        }
+        if (retryLimitDatetimeEpoch && retryLimitDatetimeEpoch !== 0) {
+            var validSendAt = sendAtEpoch;
+            if (!validSendAt || validSendAt === 0) {
+                validSendAt = Outbox.dateToEpoch(new Date());
+            }
+            if (retryLimitDatetimeEpoch < validSendAt) {
+                throw new Error('Cannot set message to stop retrying before time to send at.');
+            }
+        }
+        return [sendAtEpoch, retryLimitDatetimeEpoch];
+    };
+    Outbox.dateToEpoch = function (date) {
+        return Math.floor(date.getTime() / 1000.0);
+    };
+    return Outbox;
+}());
+exports.default = Outbox;

package/lib/models/scheduler.d.ts

@@ -34,6 +34,7 @@ export declare type SchedulerAppearanceProperties = {
     showAutoschedule?: boolean;
     showNylasBranding?: boolean;
     showTimezoneOptions?: boolean;
+    showWeekView?: boolean;
     submitText?: string;
     thankYouRedirect?: string;
     thankYouText?: string;
@@ -47,6 +48,7 @@ export declare class SchedulerAppearance extends Model implements SchedulerAppea
     showAutoschedule?: boolean;
     showNylasBranding?: boolean;
     showTimezoneOptions?: boolean;
+    showWeekView?: boolean;
     submitText?: string;
     thankYouRedirect?: string;
     thankYouText?: string;
@@ -78,13 +80,13 @@ export declare class SchedulerBookingAdditionalFields extends Model implements S
 }
 export declare type SchedulerBookingOpeningHoursProperties = {
     accountId?: string;
-    days?: string;
+    days?: string[];
     end?: string;
     start?: string;
 };
 export declare class SchedulerBookingOpeningHours extends Model implements SchedulerBookingOpeningHoursProperties {
     accountId?: string;
-    days?: string;
+    days?: string[];
     end?: string;
     start?: string;
     static attributes: Record<string, Attribute>;
@@ -92,6 +94,7 @@ export declare class SchedulerBookingOpeningHours extends Model implements Sched
 }
 export declare type SchedulerBookingProperties = {
     additionalFields?: SchedulerBookingAdditionalFieldsProperties[];
+    additionalGuestsHidden?: boolean;
     availableDaysInFuture?: number;
     calendarInviteToGuests?: boolean;
     cancellationPolicy?: string;
@@ -107,6 +110,7 @@ export declare type SchedulerBookingProperties = {
 };
 export declare class SchedulerBooking extends Model implements SchedulerBookingProperties {
     additionalFields?: SchedulerBookingAdditionalFields[];
+    additionalGuestsHidden?: boolean;
     availableDaysInFuture?: number;
     calendarInviteToGuests?: boolean;
     cancellationPolicy?: string;
@@ -179,6 +183,7 @@ export declare class SchedulerConfig extends Model implements SchedulerConfigPro
         date?: number;
         uses?: number;
     };
+    disableEmails?: boolean;
     locale?: string;
     localeForGuests?: string;
     reminders?: SchedulerRemindersProperties[];

package/lib/models/scheduler.js

@@ -108,6 +108,10 @@ var SchedulerAppearance = /** @class */ (function (_super) {
             modelKey: 'showTimezoneOptions',
             jsonKey: 'show_timezone_options',
         }),
+        showWeekView: attributes_1.default.Boolean({
+            modelKey: 'showWeekView',
+            jsonKey: 'show_week_view',
+        }),
         submitText: attributes_1.default.String({
             modelKey: 'submitText',
             jsonKey: 'submit_text',
@@ -178,7 +182,7 @@ var SchedulerBookingOpeningHours = /** @class */ (function (_super) {
             modelKey: 'accountId',
             jsonKey: 'account_id',
         }),
-        days: attributes_1.default.String({
+        days: attributes_1.default.StringList({
             modelKey: 'days',
         }),
         end: attributes_1.default.String({
@@ -204,6 +208,10 @@ var SchedulerBooking = /** @class */ (function (_super) {
             jsonKey: 'additional_fields',
             itemClass: SchedulerBookingAdditionalFields,
         }),
+        additionalGuestsHidden: attributes_1.default.Boolean({
+            modelKey: 'additionalGuestsHidden',
+            jsonKey: 'additional_guests_hidden',
+        }),
         availableDaysInFuture: attributes_1.default.Number({
             modelKey: 'availableDaysInFuture',
             jsonKey: 'available_days_in_future',
@@ -316,6 +324,10 @@ var SchedulerConfig = /** @class */ (function (_super) {
             modelKey: 'expireAfter',
             jsonKey: 'expire_after',
         }),
+        disableEmails: attributes_1.default.Boolean({
+            modelKey: 'disableEmails',
+            jsonKey: 'disable_emails',
+        }),
         locale: attributes_1.default.String({
             modelKey: 'locale',
         }),