nylas 5.7.0 → 5.10.1

package/lib/models/scheduler-booking-request.d.ts

@@ -0,0 +1,31 @@
+import RestfulModel from './restful-model';
+import SchedulerTimeSlot from './scheduler-time-slot';
+export declare class SchedulerBookingConfirmation extends RestfulModel {
+    id?: string;
+    accountId?: string;
+    additionalFieldValues?: object;
+    calendarEventId?: string;
+    calendarId?: string;
+    editHash?: string;
+    startTime?: Date;
+    endTime?: Date;
+    isConfirmed?: boolean;
+    location?: string;
+    recipientEmail?: string;
+    recipientLocale?: string;
+    recipientName?: string;
+    recipientTz?: string;
+    title?: string;
+}
+export default class SchedulerBookingRequest extends RestfulModel {
+    additionalEmails?: string[];
+    additionalValues?: object;
+    email?: string;
+    locale?: string;
+    name?: string;
+    pageHostname?: string;
+    replacesBookingHash?: string;
+    slot?: SchedulerTimeSlot;
+    timezone?: string;
+    toJSON(enforceReadOnly?: boolean): Record<string, any>;
+}

package/lib/models/scheduler-booking-request.js

@@ -0,0 +1,147 @@
+"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 });
+exports.SchedulerBookingConfirmation = void 0;
+var restful_model_1 = __importDefault(require("./restful-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var scheduler_time_slot_1 = __importDefault(require("./scheduler-time-slot"));
+var SchedulerBookingConfirmation = /** @class */ (function (_super) {
+    __extends(SchedulerBookingConfirmation, _super);
+    function SchedulerBookingConfirmation() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return SchedulerBookingConfirmation;
+}(restful_model_1.default));
+exports.SchedulerBookingConfirmation = SchedulerBookingConfirmation;
+SchedulerBookingConfirmation.collectionName = 'booking_confirmation';
+SchedulerBookingConfirmation.attributes = {
+    id: attributes_1.default.Number({
+        modelKey: 'id',
+    }),
+    accountId: attributes_1.default.String({
+        modelKey: 'accountId',
+        jsonKey: 'account_id',
+    }),
+    additionalFieldValues: attributes_1.default.Object({
+        modelKey: 'additionalFieldValues',
+        jsonKey: 'additional_field_values',
+    }),
+    calendarEventId: attributes_1.default.String({
+        modelKey: 'calendarEventId',
+        jsonKey: 'calendar_event_id',
+    }),
+    calendarId: attributes_1.default.String({
+        modelKey: 'calendarId',
+        jsonKey: 'calendar_id',
+    }),
+    editHash: attributes_1.default.String({
+        modelKey: 'editHash',
+        jsonKey: 'edit_hash',
+    }),
+    startTime: attributes_1.default.DateTime({
+        modelKey: 'startTime',
+        jsonKey: 'start_time',
+    }),
+    endTime: attributes_1.default.DateTime({
+        modelKey: 'endTime',
+        jsonKey: 'end_time',
+    }),
+    isConfirmed: attributes_1.default.Boolean({
+        modelKey: 'isConfirmed',
+        jsonKey: 'is_confirmed',
+    }),
+    location: attributes_1.default.String({
+        modelKey: 'location',
+    }),
+    recipientEmail: attributes_1.default.String({
+        modelKey: 'recipientEmail',
+        jsonKey: 'recipient_email',
+    }),
+    recipientLocale: attributes_1.default.String({
+        modelKey: 'recipientLocale',
+        jsonKey: 'recipient_locale',
+    }),
+    recipientName: attributes_1.default.String({
+        modelKey: 'recipientName',
+        jsonKey: 'recipient_name',
+    }),
+    recipientTz: attributes_1.default.String({
+        modelKey: 'recipientTz',
+        jsonKey: 'recipient_tz',
+    }),
+    title: attributes_1.default.String({
+        modelKey: 'title',
+    }),
+};
+var SchedulerBookingRequest = /** @class */ (function (_super) {
+    __extends(SchedulerBookingRequest, _super);
+    function SchedulerBookingRequest() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /*
+    * The booking endpoint requires additional_values and additional_emails
+      to exist regardless if they are empty or not
+    */
+    SchedulerBookingRequest.prototype.toJSON = function (enforceReadOnly) {
+        var json = _super.prototype.toJSON.call(this, enforceReadOnly);
+        if (!this.additionalEmails) {
+            json['additional_emails'] = [];
+        }
+        if (!this.additionalValues) {
+            json['additional_values'] = {};
+        }
+        return json;
+    };
+    return SchedulerBookingRequest;
+}(restful_model_1.default));
+exports.default = SchedulerBookingRequest;
+SchedulerBookingRequest.collectionName = 'booking_request';
+SchedulerBookingRequest.attributes = {
+    additionalEmails: attributes_1.default.StringList({
+        modelKey: 'additionalEmails',
+        jsonKey: 'additional_emails',
+    }),
+    additionalValues: attributes_1.default.Object({
+        modelKey: 'additionalValues',
+        jsonKey: 'additional_values',
+    }),
+    email: attributes_1.default.String({
+        modelKey: 'email',
+    }),
+    locale: attributes_1.default.String({
+        modelKey: 'locale',
+    }),
+    name: attributes_1.default.String({
+        modelKey: 'name',
+    }),
+    pageHostname: attributes_1.default.String({
+        modelKey: 'pageHostname',
+        jsonKey: 'page_hostname',
+    }),
+    replacesBookingHash: attributes_1.default.String({
+        modelKey: 'replacesBookingHash',
+        jsonKey: 'replaces_booking_hash',
+    }),
+    slot: attributes_1.default.Object({
+        modelKey: 'slot',
+        itemClass: scheduler_time_slot_1.default,
+    }),
+    timezone: attributes_1.default.String({
+        modelKey: 'timezone',
+    }),
+};

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

@@ -0,0 +1,25 @@
+import RestfulModelCollection from './restful-model-collection';
+import NylasConnection from '../nylas-connection';
+import Scheduler from './scheduler';
+import SchedulerTimeSlot from './scheduler-time-slot';
+import SchedulerBookingRequest, { SchedulerBookingConfirmation } from './scheduler-booking-request';
+export declare type ProviderAvailability = {
+    busy: [{
+        end: number;
+        start: number;
+    }];
+    email: string;
+    name: string;
+};
+export default class SchedulerRestfulModelCollection extends RestfulModelCollection<Scheduler> {
+    connection: NylasConnection;
+    modelClass: typeof Scheduler;
+    constructor(connection: NylasConnection);
+    getGoogleAvailability(): Promise<ProviderAvailability>;
+    getOffice365Availability(): Promise<ProviderAvailability>;
+    getPageBySlug(slug: string): Promise<Scheduler>;
+    getAvailableTimeSlots(slug: string): Promise<SchedulerTimeSlot[]>;
+    bookTimeSlot(slug: string, bookingRequest: SchedulerBookingRequest): Promise<SchedulerBookingConfirmation>;
+    cancelBooking(slug: string, editHash: string, reason: string): Record<string, any>;
+    confirmBooking(slug: string, editHash: string): Promise<SchedulerBookingConfirmation>;
+}

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

@@ -0,0 +1,136 @@
+"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_collection_1 = __importDefault(require("./restful-model-collection"));
+var scheduler_1 = __importDefault(require("./scheduler"));
+var scheduler_time_slot_1 = __importDefault(require("./scheduler-time-slot"));
+var scheduler_booking_request_1 = require("./scheduler-booking-request");
+var SchedulerRestfulModelCollection = /** @class */ (function (_super) {
+    __extends(SchedulerRestfulModelCollection, _super);
+    function SchedulerRestfulModelCollection(connection) {
+        var _this = _super.call(this, scheduler_1.default, connection) || this;
+        _this.baseUrl = 'https://api.schedule.nylas.com';
+        _this.connection = connection;
+        _this.modelClass = scheduler_1.default;
+        return _this;
+    }
+    SchedulerRestfulModelCollection.prototype.getGoogleAvailability = function () {
+        return this.connection.request({
+            method: 'GET',
+            path: '/schedule/availability/google',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            baseUrl: this.baseUrl,
+        });
+    };
+    SchedulerRestfulModelCollection.prototype.getOffice365Availability = function () {
+        return this.connection.request({
+            method: 'GET',
+            path: '/schedule/availability/o365',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            baseUrl: this.baseUrl,
+        });
+    };
+    SchedulerRestfulModelCollection.prototype.getPageBySlug = function (slug) {
+        var _this = this;
+        return this.connection
+            .request({
+            method: 'GET',
+            path: "/schedule/" + slug + "/info",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            baseUrl: this.baseUrl,
+        })
+            .then(function (json) {
+            return Promise.resolve(new scheduler_1.default(_this.connection, json));
+        });
+    };
+    SchedulerRestfulModelCollection.prototype.getAvailableTimeSlots = function (slug) {
+        var _this = this;
+        return this.connection
+            .request({
+            method: 'GET',
+            path: "/schedule/" + slug + "/timeslots",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            baseUrl: this.baseUrl,
+        })
+            .then(function (json) {
+            var timeslots = json.map(function (timeslot) {
+                return new scheduler_time_slot_1.default(_this.connection, timeslot);
+            });
+            return Promise.resolve(timeslots);
+        });
+    };
+    SchedulerRestfulModelCollection.prototype.bookTimeSlot = function (slug, bookingRequest) {
+        var _this = this;
+        return this.connection
+            .request({
+            method: 'POST',
+            path: "/schedule/" + slug + "/timeslots",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: bookingRequest.toJSON(),
+            baseUrl: this.baseUrl,
+        })
+            .then(function (json) {
+            return Promise.resolve(new scheduler_booking_request_1.SchedulerBookingConfirmation(_this.connection, json));
+        });
+    };
+    SchedulerRestfulModelCollection.prototype.cancelBooking = function (slug, editHash, reason) {
+        return this.connection
+            .request({
+            method: 'POST',
+            path: "/schedule/" + slug + "/" + editHash + "/cancel",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: {
+                reason: reason,
+            },
+            baseUrl: this.baseUrl,
+        })
+            .then(function (json) {
+            return Promise.resolve(json);
+        });
+    };
+    SchedulerRestfulModelCollection.prototype.confirmBooking = function (slug, editHash) {
+        var _this = this;
+        return this.connection
+            .request({
+            method: 'POST',
+            path: "/schedule/" + slug + "/" + editHash + "/confirm",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: {},
+            baseUrl: this.baseUrl,
+        })
+            .then(function (json) {
+            return Promise.resolve(new scheduler_booking_request_1.SchedulerBookingConfirmation(_this.connection, json));
+        });
+    };
+    return SchedulerRestfulModelCollection;
+}(restful_model_collection_1.default));
+exports.default = SchedulerRestfulModelCollection;

package/lib/models/scheduler-time-slot.d.ts

@@ -0,0 +1,9 @@
+import RestfulModel from './restful-model';
+export default class SchedulerTimeSlot extends RestfulModel {
+    accountId?: string;
+    calendarId?: string;
+    hostName?: string;
+    emails?: string[];
+    start?: Date;
+    end?: Date;
+}

package/lib/models/scheduler-time-slot.js

@@ -0,0 +1,52 @@
+"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 SchedulerTimeSlot = /** @class */ (function (_super) {
+    __extends(SchedulerTimeSlot, _super);
+    function SchedulerTimeSlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return SchedulerTimeSlot;
+}(restful_model_1.default));
+exports.default = SchedulerTimeSlot;
+SchedulerTimeSlot.collectionName = 'scheduler_slot';
+SchedulerTimeSlot.attributes = {
+    accountId: attributes_1.default.String({
+        modelKey: 'accountId',
+        jsonKey: 'account_id',
+    }),
+    calendarId: attributes_1.default.String({
+        modelKey: 'calendarId',
+        jsonKey: 'calendar_id',
+    }),
+    hostName: attributes_1.default.String({
+        modelKey: 'hostName',
+        jsonKey: 'host_name',
+    }),
+    emails: attributes_1.default.StringList({
+        modelKey: 'emails',
+    }),
+    start: attributes_1.default.DateTime({
+        modelKey: 'start',
+    }),
+    end: attributes_1.default.DateTime({
+        modelKey: 'end',
+    }),
+};

package/lib/models/scheduler.d.ts

@@ -0,0 +1,98 @@
+import RestfulModel, { SaveCallback } from './restful-model';
+import NylasConnection from '../nylas-connection';
+import Calendar from './calendar';
+export declare type SchedulerUploadImageResponse = {
+    filename: string;
+    originalFilename: string;
+    publicUrl: string;
+    signedUrl: string;
+};
+export declare class SchedulerAvailableCalendars extends RestfulModel {
+    calendars?: Calendar[];
+    email?: string;
+    id?: string;
+    name?: string;
+}
+export default class Scheduler extends RestfulModel {
+    accessTokens?: string[];
+    appClientId?: string;
+    appOrganizationId?: number;
+    config?: {
+        appearance?: {
+            color?: string;
+            company_name?: string;
+            logo?: string;
+            privacy_policy_redirect?: string;
+            show_autoschedule?: boolean;
+            show_nylas_branding?: boolean;
+            show_timezone_options?: boolean;
+            submit_text?: string;
+            thank_you_redirect?: string;
+            thank_you_text?: string;
+            thank_you_text_secondary?: string;
+        };
+        booking?: {
+            additional_fields: Array<{
+                dropdown_options?: string[];
+                label?: string;
+                multi_select_options?: string[];
+                name?: string;
+                order?: number;
+                pattern?: string;
+                required?: boolean;
+                type?: string;
+            }>;
+            available_days_in_future: number;
+            calendar_invite_to_guests: boolean;
+            cancellation_policy: string;
+            confirmation_emails_to_guests: boolean;
+            confirmation_emails_to_host: boolean;
+            confirmation_method: string;
+            min_booking_notice: number;
+            min_buffer: number;
+            min_cancellation_notice: number;
+            name_field_hidden: boolean;
+            opening_hours: Array<{
+                account_id?: string;
+                days?: string;
+                end?: string;
+                start?: string;
+            }>;
+            scheduling_method: string;
+        };
+        calendar_ids?: {
+            [accountId: string]: {
+                availability?: string[];
+                booking?: string;
+            };
+        };
+        event?: {
+            duration?: number;
+            location?: string;
+            title?: string;
+        };
+        expire_after?: {
+            date?: number;
+            uses?: number;
+        };
+        locale?: string;
+        locale_for_guests?: string;
+        reminders?: Array<{
+            delivery_method?: string;
+            delivery_recipient?: string;
+            email_subject?: string;
+            time_before_event?: number;
+            webhook_url?: string;
+        }>;
+        timezone?: string;
+    };
+    editToken?: string;
+    name?: string;
+    slug?: string;
+    createdAt?: Date;
+    modifiedAt?: Date;
+    constructor(connection: NylasConnection, json?: Record<string, any>);
+    save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
+    getAvailableCalendars(): Promise<SchedulerAvailableCalendars[]>;
+    uploadImage(contentType: string, objectName: string): Promise<SchedulerUploadImageResponse>;
+}

package/lib/models/scheduler.js

@@ -0,0 +1,140 @@
+"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 });
+exports.SchedulerAvailableCalendars = void 0;
+var restful_model_1 = __importDefault(require("./restful-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var calendar_1 = __importDefault(require("./calendar"));
+var SchedulerAvailableCalendars = /** @class */ (function (_super) {
+    __extends(SchedulerAvailableCalendars, _super);
+    function SchedulerAvailableCalendars() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return SchedulerAvailableCalendars;
+}(restful_model_1.default));
+exports.SchedulerAvailableCalendars = SchedulerAvailableCalendars;
+SchedulerAvailableCalendars.collectionName = 'scheduler_available_calendars';
+SchedulerAvailableCalendars.attributes = {
+    calendars: attributes_1.default.Collection({
+        modelKey: 'calendars',
+        itemClass: calendar_1.default,
+    }),
+    email: attributes_1.default.String({
+        modelKey: 'email',
+    }),
+    id: attributes_1.default.String({
+        modelKey: 'id',
+    }),
+    name: attributes_1.default.String({
+        modelKey: 'name',
+    }),
+};
+var Scheduler = /** @class */ (function (_super) {
+    __extends(Scheduler, _super);
+    function Scheduler(connection, json) {
+        var _this = _super.call(this, connection, json) || this;
+        _this.baseUrl = 'https://api.schedule.nylas.com';
+        return _this;
+    }
+    Scheduler.prototype.save = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this._save(params, callback);
+    };
+    Scheduler.prototype.getAvailableCalendars = function () {
+        var _this = this;
+        if (!this.id) {
+            throw new Error('Cannot get calendars for a page without an ID.');
+        }
+        return this.connection
+            .request({
+            method: 'GET',
+            path: "/manage/pages/" + this.id + "/calendars",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            baseUrl: this.baseUrl,
+        })
+            .then(function (json) {
+            var calendars = json.map(function (cal) {
+                return new SchedulerAvailableCalendars(_this.connection, cal);
+            });
+            return Promise.resolve(calendars);
+        });
+    };
+    Scheduler.prototype.uploadImage = function (contentType, objectName) {
+        if (!this.id) {
+            throw new Error('Cannot upload an image to a page without an ID.');
+        }
+        return this.connection.request({
+            method: 'PUT',
+            path: "/manage/pages/" + this.id + "/upload-image",
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: {
+                contentType: contentType,
+                objectName: objectName,
+            },
+            baseUrl: this.baseUrl,
+        });
+    };
+    return Scheduler;
+}(restful_model_1.default));
+exports.default = Scheduler;
+Scheduler.collectionName = 'manage/pages';
+Scheduler.attributes = __assign(__assign({}, restful_model_1.default.attributes), { accessTokens: attributes_1.default.StringList({
+        modelKey: 'accessTokens',
+        jsonKey: 'access_tokens',
+    }), appClientId: attributes_1.default.String({
+        modelKey: 'appClientId',
+        jsonKey: 'app_client_id',
+        readOnly: true,
+    }), appOrganizationId: attributes_1.default.Number({
+        modelKey: 'appOrganizationId',
+        jsonKey: 'app_organization_id',
+        readOnly: true,
+    }), config: attributes_1.default.Object({
+        modelKey: 'config',
+    }), editToken: attributes_1.default.String({
+        modelKey: 'editToken',
+        jsonKey: 'edit_token',
+        readOnly: true,
+    }), name: attributes_1.default.String({
+        modelKey: 'name',
+    }), slug: attributes_1.default.String({
+        modelKey: 'slug',
+    }), createdAt: attributes_1.default.Date({
+        modelKey: 'createdAt',
+        jsonKey: 'created_at',
+        readOnly: true,
+    }), modifiedAt: attributes_1.default.Date({
+        modelKey: 'modifiedAt',
+        jsonKey: 'modified_at',
+        readOnly: true,
+    }) });

package/lib/nylas-connection.d.ts

@@ -17,6 +17,8 @@ import Delta from './models/delta';
 import { Folder, Label } from './models/folder';
 import { AppendOptions } from 'form-data';
 import Neural from './models/neural';
+import ComponentRestfulModelCollection from './models/component-restful-model-collection';
+import SchedulerRestfulModelCollection from './models/scheduler-restful-model-collection';
 export declare type RequestOptions = {
     path: string;
     method?: string;
@@ -32,6 +34,7 @@ export declare type RequestOptions = {
         [key: string]: FormDataType;
     };
     body?: any;
+    baseUrl?: string;
     url?: URL;
 };
 export declare type FormDataType = {
@@ -56,6 +59,8 @@ export default class NylasConnection {
     labels: RestfulModelCollection<Label>;
     folders: RestfulModelCollection<Folder>;
     account: RestfulModelInstance<Account>;
+    component: ComponentRestfulModelCollection;
+    scheduler: SchedulerRestfulModelCollection;
     neural: Neural;
     constructor(accessToken: string | null | undefined, { clientId }: {
         clientId: string | null | undefined;