files.com 1.2.248 → 1.2.250

package/lib/models/Site.js

@@ -734,16 +734,16 @@ _Site = Site;
   var options,
     response,
     _args = arguments;
-  return _regenerator.default.wrap(function _callee$(_context) {
+  return _regenerator.default.wrap(function (_context) {
     while (1) switch (_context.prev = _context.next) {
       case 0:
         options = _args.length > 0 && _args[0] !== undefined ? _args[0] : {};
-        _context.next = 3;
+        _context.next = 1;
         return _Api.default.sendRequest('/site', 'GET', {}, options);
-      case 3:
+      case 1:
         response = _context.sent;
         return _context.abrupt("return", new _Site(response === null || response === void 0 ? void 0 : response.data, options));
-      case 5:
+      case 2:
       case "end":
         return _context.stop();
     }
@@ -754,17 +754,17 @@ _Site = Site;
     response,
     UsageSnapshot,
     _args2 = arguments;
-  return _regenerator.default.wrap(function _callee2$(_context2) {
+  return _regenerator.default.wrap(function (_context2) {
     while (1) switch (_context2.prev = _context2.next) {
       case 0:
         options = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
-        _context2.next = 3;
+        _context2.next = 1;
         return _Api.default.sendRequest('/site/usage', 'GET', {}, options);
-      case 3:
+      case 1:
         response = _context2.sent;
         UsageSnapshot = require('./UsageSnapshot.js').default;
         return _context2.abrupt("return", new UsageSnapshot(response === null || response === void 0 ? void 0 : response.data, options));
-      case 6:
+      case 2:
       case "end":
         return _context2.stop();
     }
@@ -941,431 +941,431 @@ _Site = Site;
     options,
     response,
     _args3 = arguments;
-  return _regenerator.default.wrap(function _callee3$(_context3) {
+  return _regenerator.default.wrap(function (_context3) {
     while (1) switch (_context3.prev = _context3.next) {
       case 0:
         params = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {};
         options = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
         if (!(params.name && !(0, _utils.isString)(params.name))) {
-          _context3.next = 4;
+          _context3.next = 1;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: name must be of type String, received ".concat((0, _utils.getType)(params.name)));
-      case 4:
+      case 1:
         if (!(params.subdomain && !(0, _utils.isString)(params.subdomain))) {
-          _context3.next = 6;
+          _context3.next = 2;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: subdomain must be of type String, received ".concat((0, _utils.getType)(params.subdomain)));
-      case 6:
+      case 2:
         if (!(params.domain && !(0, _utils.isString)(params.domain))) {
-          _context3.next = 8;
+          _context3.next = 3;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: domain must be of type String, received ".concat((0, _utils.getType)(params.domain)));
-      case 8:
+      case 3:
         if (!(params.domain_letsencrypt_chain && !(0, _utils.isString)(params.domain_letsencrypt_chain))) {
-          _context3.next = 10;
+          _context3.next = 4;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: domain_letsencrypt_chain must be of type String, received ".concat((0, _utils.getType)(params.domain_letsencrypt_chain)));
-      case 10:
+      case 4:
         if (!(params.email && !(0, _utils.isString)(params.email))) {
-          _context3.next = 12;
+          _context3.next = 5;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: email must be of type String, received ".concat((0, _utils.getType)(params.email)));
-      case 12:
+      case 5:
         if (!(params.reply_to_email && !(0, _utils.isString)(params.reply_to_email))) {
-          _context3.next = 14;
+          _context3.next = 6;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: reply_to_email must be of type String, received ".concat((0, _utils.getType)(params.reply_to_email)));
-      case 14:
+      case 6:
         if (!(params.bundle_expiration && !(0, _utils.isInt)(params.bundle_expiration))) {
-          _context3.next = 16;
+          _context3.next = 7;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: bundle_expiration must be of type Int, received ".concat((0, _utils.getType)(params.bundle_expiration)));
-      case 16:
+      case 7:
         if (!(params.welcome_email_cc && !(0, _utils.isString)(params.welcome_email_cc))) {
-          _context3.next = 18;
+          _context3.next = 8;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: welcome_email_cc must be of type String, received ".concat((0, _utils.getType)(params.welcome_email_cc)));
-      case 18:
+      case 8:
         if (!(params.welcome_email_subject && !(0, _utils.isString)(params.welcome_email_subject))) {
-          _context3.next = 20;
+          _context3.next = 9;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: welcome_email_subject must be of type String, received ".concat((0, _utils.getType)(params.welcome_email_subject)));
-      case 20:
+      case 9:
         if (!(params.welcome_custom_text && !(0, _utils.isString)(params.welcome_custom_text))) {
-          _context3.next = 22;
+          _context3.next = 10;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: welcome_custom_text must be of type String, received ".concat((0, _utils.getType)(params.welcome_custom_text)));
-      case 22:
+      case 10:
         if (!(params.language && !(0, _utils.isString)(params.language))) {
-          _context3.next = 24;
+          _context3.next = 11;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: language must be of type String, received ".concat((0, _utils.getType)(params.language)));
-      case 24:
+      case 11:
         if (!(params.default_time_zone && !(0, _utils.isString)(params.default_time_zone))) {
-          _context3.next = 26;
+          _context3.next = 12;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: default_time_zone must be of type String, received ".concat((0, _utils.getType)(params.default_time_zone)));
-      case 26:
+      case 12:
         if (!(params.desktop_app_session_lifetime && !(0, _utils.isInt)(params.desktop_app_session_lifetime))) {
-          _context3.next = 28;
+          _context3.next = 13;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: desktop_app_session_lifetime must be of type Int, received ".concat((0, _utils.getType)(params.desktop_app_session_lifetime)));
-      case 28:
+      case 13:
         if (!(params.mobile_app_session_lifetime && !(0, _utils.isInt)(params.mobile_app_session_lifetime))) {
-          _context3.next = 30;
+          _context3.next = 14;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: mobile_app_session_lifetime must be of type Int, received ".concat((0, _utils.getType)(params.mobile_app_session_lifetime)));
-      case 30:
+      case 14:
         if (!(params.welcome_screen && !(0, _utils.isString)(params.welcome_screen))) {
-          _context3.next = 32;
+          _context3.next = 15;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: welcome_screen must be of type String, received ".concat((0, _utils.getType)(params.welcome_screen)));
-      case 32:
+      case 15:
         if (!(params.office_integration_type && !(0, _utils.isString)(params.office_integration_type))) {
-          _context3.next = 34;
+          _context3.next = 16;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: office_integration_type must be of type String, received ".concat((0, _utils.getType)(params.office_integration_type)));
-      case 34:
+      case 16:
         if (!(params.motd_text && !(0, _utils.isString)(params.motd_text))) {
-          _context3.next = 36;
+          _context3.next = 17;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: motd_text must be of type String, received ".concat((0, _utils.getType)(params.motd_text)));
-      case 36:
+      case 17:
         if (!(params.additional_text_file_types && !(0, _utils.isArray)(params.additional_text_file_types))) {
-          _context3.next = 38;
+          _context3.next = 18;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: additional_text_file_types must be of type Array, received ".concat((0, _utils.getType)(params.additional_text_file_types)));
-      case 38:
+      case 18:
         if (!(params.user_lockout_tries && !(0, _utils.isInt)(params.user_lockout_tries))) {
-          _context3.next = 40;
+          _context3.next = 19;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: user_lockout_tries must be of type Int, received ".concat((0, _utils.getType)(params.user_lockout_tries)));
-      case 40:
+      case 19:
         if (!(params.user_lockout_within && !(0, _utils.isInt)(params.user_lockout_within))) {
-          _context3.next = 42;
+          _context3.next = 20;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: user_lockout_within must be of type Int, received ".concat((0, _utils.getType)(params.user_lockout_within)));
-      case 42:
+      case 20:
         if (!(params.user_lockout_lock_period && !(0, _utils.isInt)(params.user_lockout_lock_period))) {
-          _context3.next = 44;
+          _context3.next = 21;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: user_lockout_lock_period must be of type Int, received ".concat((0, _utils.getType)(params.user_lockout_lock_period)));
-      case 44:
+      case 21:
         if (!(params.allowed_countries && !(0, _utils.isString)(params.allowed_countries))) {
-          _context3.next = 46;
+          _context3.next = 22;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: allowed_countries must be of type String, received ".concat((0, _utils.getType)(params.allowed_countries)));
-      case 46:
+      case 22:
         if (!(params.allowed_ips && !(0, _utils.isString)(params.allowed_ips))) {
-          _context3.next = 48;
+          _context3.next = 23;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: allowed_ips must be of type String, received ".concat((0, _utils.getType)(params.allowed_ips)));
-      case 48:
+      case 23:
         if (!(params.disallowed_countries && !(0, _utils.isString)(params.disallowed_countries))) {
-          _context3.next = 50;
+          _context3.next = 24;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: disallowed_countries must be of type String, received ".concat((0, _utils.getType)(params.disallowed_countries)));
-      case 50:
+      case 24:
         if (!(params.days_before_deleting_disabled_users && !(0, _utils.isInt)(params.days_before_deleting_disabled_users))) {
-          _context3.next = 52;
+          _context3.next = 25;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: days_before_deleting_disabled_users must be of type Int, received ".concat((0, _utils.getType)(params.days_before_deleting_disabled_users)));
-      case 52:
+      case 25:
         if (!(params.days_to_retain_backups && !(0, _utils.isInt)(params.days_to_retain_backups))) {
-          _context3.next = 54;
+          _context3.next = 26;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: days_to_retain_backups must be of type Int, received ".concat((0, _utils.getType)(params.days_to_retain_backups)));
-      case 54:
+      case 26:
         if (!(params.max_prior_passwords && !(0, _utils.isInt)(params.max_prior_passwords))) {
-          _context3.next = 56;
+          _context3.next = 27;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: max_prior_passwords must be of type Int, received ".concat((0, _utils.getType)(params.max_prior_passwords)));
-      case 56:
+      case 27:
         if (!(params.password_validity_days && !(0, _utils.isInt)(params.password_validity_days))) {
-          _context3.next = 58;
+          _context3.next = 28;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: password_validity_days must be of type Int, received ".concat((0, _utils.getType)(params.password_validity_days)));
-      case 58:
+      case 28:
         if (!(params.password_min_length && !(0, _utils.isInt)(params.password_min_length))) {
-          _context3.next = 60;
+          _context3.next = 29;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: password_min_length must be of type Int, received ".concat((0, _utils.getType)(params.password_min_length)));
-      case 60:
+      case 29:
         if (!(params.bundle_not_found_message && !(0, _utils.isString)(params.bundle_not_found_message))) {
-          _context3.next = 62;
+          _context3.next = 30;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: bundle_not_found_message must be of type String, received ".concat((0, _utils.getType)(params.bundle_not_found_message)));
-      case 62:
+      case 30:
         if (!(params.bundle_registration_notifications && !(0, _utils.isString)(params.bundle_registration_notifications))) {
-          _context3.next = 64;
+          _context3.next = 31;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: bundle_registration_notifications must be of type String, received ".concat((0, _utils.getType)(params.bundle_registration_notifications)));
-      case 64:
+      case 31:
         if (!(params.bundle_activity_notifications && !(0, _utils.isString)(params.bundle_activity_notifications))) {
-          _context3.next = 66;
+          _context3.next = 32;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: bundle_activity_notifications must be of type String, received ".concat((0, _utils.getType)(params.bundle_activity_notifications)));
-      case 66:
+      case 32:
         if (!(params.bundle_upload_receipt_notifications && !(0, _utils.isString)(params.bundle_upload_receipt_notifications))) {
-          _context3.next = 68;
+          _context3.next = 33;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: bundle_upload_receipt_notifications must be of type String, received ".concat((0, _utils.getType)(params.bundle_upload_receipt_notifications)));
-      case 68:
+      case 33:
         if (!(params.disable_users_from_inactivity_period_days && !(0, _utils.isInt)(params.disable_users_from_inactivity_period_days))) {
-          _context3.next = 70;
+          _context3.next = 34;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: disable_users_from_inactivity_period_days must be of type Int, received ".concat((0, _utils.getType)(params.disable_users_from_inactivity_period_days)));
-      case 70:
+      case 34:
         if (!(params.sftp_host_key_type && !(0, _utils.isString)(params.sftp_host_key_type))) {
-          _context3.next = 72;
+          _context3.next = 35;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: sftp_host_key_type must be of type String, received ".concat((0, _utils.getType)(params.sftp_host_key_type)));
-      case 72:
+      case 35:
         if (!(params.active_sftp_host_key_id && !(0, _utils.isInt)(params.active_sftp_host_key_id))) {
-          _context3.next = 74;
+          _context3.next = 36;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: active_sftp_host_key_id must be of type Int, received ".concat((0, _utils.getType)(params.active_sftp_host_key_id)));
-      case 74:
+      case 36:
         if (!(params.bundle_recipient_blacklist_domains && !(0, _utils.isArray)(params.bundle_recipient_blacklist_domains))) {
-          _context3.next = 76;
+          _context3.next = 37;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: bundle_recipient_blacklist_domains must be of type Array, received ".concat((0, _utils.getType)(params.bundle_recipient_blacklist_domains)));
-      case 76:
+      case 37:
         if (!(params.require_2fa_user_type && !(0, _utils.isString)(params.require_2fa_user_type))) {
-          _context3.next = 78;
+          _context3.next = 38;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: require_2fa_user_type must be of type String, received ".concat((0, _utils.getType)(params.require_2fa_user_type)));
-      case 78:
+      case 38:
         if (!(params.color2_top && !(0, _utils.isString)(params.color2_top))) {
-          _context3.next = 80;
+          _context3.next = 39;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: color2_top must be of type String, received ".concat((0, _utils.getType)(params.color2_top)));
-      case 80:
+      case 39:
         if (!(params.color2_left && !(0, _utils.isString)(params.color2_left))) {
-          _context3.next = 82;
+          _context3.next = 40;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: color2_left must be of type String, received ".concat((0, _utils.getType)(params.color2_left)));
-      case 82:
+      case 40:
         if (!(params.color2_link && !(0, _utils.isString)(params.color2_link))) {
-          _context3.next = 84;
+          _context3.next = 41;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: color2_link must be of type String, received ".concat((0, _utils.getType)(params.color2_link)));
-      case 84:
+      case 41:
         if (!(params.color2_text && !(0, _utils.isString)(params.color2_text))) {
-          _context3.next = 86;
+          _context3.next = 42;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: color2_text must be of type String, received ".concat((0, _utils.getType)(params.color2_text)));
-      case 86:
+      case 42:
         if (!(params.color2_top_text && !(0, _utils.isString)(params.color2_top_text))) {
-          _context3.next = 88;
+          _context3.next = 43;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: color2_top_text must be of type String, received ".concat((0, _utils.getType)(params.color2_top_text)));
-      case 88:
+      case 43:
         if (!(params.site_header && !(0, _utils.isString)(params.site_header))) {
-          _context3.next = 90;
+          _context3.next = 44;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: site_header must be of type String, received ".concat((0, _utils.getType)(params.site_header)));
-      case 90:
+      case 44:
         if (!(params.site_footer && !(0, _utils.isString)(params.site_footer))) {
-          _context3.next = 92;
+          _context3.next = 45;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: site_footer must be of type String, received ".concat((0, _utils.getType)(params.site_footer)));
-      case 92:
+      case 45:
         if (!(params.login_help_text && !(0, _utils.isString)(params.login_help_text))) {
-          _context3.next = 94;
+          _context3.next = 46;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: login_help_text must be of type String, received ".concat((0, _utils.getType)(params.login_help_text)));
-      case 94:
+      case 46:
         if (!(params.smtp_address && !(0, _utils.isString)(params.smtp_address))) {
-          _context3.next = 96;
+          _context3.next = 47;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: smtp_address must be of type String, received ".concat((0, _utils.getType)(params.smtp_address)));
-      case 96:
+      case 47:
         if (!(params.smtp_authentication && !(0, _utils.isString)(params.smtp_authentication))) {
-          _context3.next = 98;
+          _context3.next = 48;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: smtp_authentication must be of type String, received ".concat((0, _utils.getType)(params.smtp_authentication)));
-      case 98:
+      case 48:
         if (!(params.smtp_from && !(0, _utils.isString)(params.smtp_from))) {
-          _context3.next = 100;
+          _context3.next = 49;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: smtp_from must be of type String, received ".concat((0, _utils.getType)(params.smtp_from)));
-      case 100:
+      case 49:
         if (!(params.smtp_username && !(0, _utils.isString)(params.smtp_username))) {
-          _context3.next = 102;
+          _context3.next = 50;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: smtp_username must be of type String, received ".concat((0, _utils.getType)(params.smtp_username)));
-      case 102:
+      case 50:
         if (!(params.smtp_port && !(0, _utils.isInt)(params.smtp_port))) {
-          _context3.next = 104;
+          _context3.next = 51;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: smtp_port must be of type Int, received ".concat((0, _utils.getType)(params.smtp_port)));
-      case 104:
+      case 51:
         if (!(params.ldap_type && !(0, _utils.isString)(params.ldap_type))) {
-          _context3.next = 106;
+          _context3.next = 52;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_type must be of type String, received ".concat((0, _utils.getType)(params.ldap_type)));
-      case 106:
+      case 52:
         if (!(params.ldap_host && !(0, _utils.isString)(params.ldap_host))) {
-          _context3.next = 108;
+          _context3.next = 53;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_host must be of type String, received ".concat((0, _utils.getType)(params.ldap_host)));
-      case 108:
+      case 53:
         if (!(params.ldap_host_2 && !(0, _utils.isString)(params.ldap_host_2))) {
-          _context3.next = 110;
+          _context3.next = 54;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_host_2 must be of type String, received ".concat((0, _utils.getType)(params.ldap_host_2)));
-      case 110:
+      case 54:
         if (!(params.ldap_host_3 && !(0, _utils.isString)(params.ldap_host_3))) {
-          _context3.next = 112;
+          _context3.next = 55;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_host_3 must be of type String, received ".concat((0, _utils.getType)(params.ldap_host_3)));
-      case 112:
+      case 55:
         if (!(params.ldap_port && !(0, _utils.isInt)(params.ldap_port))) {
-          _context3.next = 114;
+          _context3.next = 56;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_port must be of type Int, received ".concat((0, _utils.getType)(params.ldap_port)));
-      case 114:
+      case 56:
         if (!(params.ldap_username && !(0, _utils.isString)(params.ldap_username))) {
-          _context3.next = 116;
+          _context3.next = 57;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_username must be of type String, received ".concat((0, _utils.getType)(params.ldap_username)));
-      case 116:
+      case 57:
         if (!(params.ldap_username_field && !(0, _utils.isString)(params.ldap_username_field))) {
-          _context3.next = 118;
+          _context3.next = 58;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_username_field must be of type String, received ".concat((0, _utils.getType)(params.ldap_username_field)));
-      case 118:
+      case 58:
         if (!(params.ldap_domain && !(0, _utils.isString)(params.ldap_domain))) {
-          _context3.next = 120;
+          _context3.next = 59;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_domain must be of type String, received ".concat((0, _utils.getType)(params.ldap_domain)));
-      case 120:
+      case 59:
         if (!(params.ldap_user_action && !(0, _utils.isString)(params.ldap_user_action))) {
-          _context3.next = 122;
+          _context3.next = 60;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_user_action must be of type String, received ".concat((0, _utils.getType)(params.ldap_user_action)));
-      case 122:
+      case 60:
         if (!(params.ldap_group_action && !(0, _utils.isString)(params.ldap_group_action))) {
-          _context3.next = 124;
+          _context3.next = 61;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_group_action must be of type String, received ".concat((0, _utils.getType)(params.ldap_group_action)));
-      case 124:
+      case 61:
         if (!(params.ldap_user_include_groups && !(0, _utils.isString)(params.ldap_user_include_groups))) {
-          _context3.next = 126;
+          _context3.next = 62;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_user_include_groups must be of type String, received ".concat((0, _utils.getType)(params.ldap_user_include_groups)));
-      case 126:
+      case 62:
         if (!(params.ldap_group_exclusion && !(0, _utils.isString)(params.ldap_group_exclusion))) {
-          _context3.next = 128;
+          _context3.next = 63;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_group_exclusion must be of type String, received ".concat((0, _utils.getType)(params.ldap_group_exclusion)));
-      case 128:
+      case 63:
         if (!(params.ldap_group_inclusion && !(0, _utils.isString)(params.ldap_group_inclusion))) {
-          _context3.next = 130;
+          _context3.next = 64;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_group_inclusion must be of type String, received ".concat((0, _utils.getType)(params.ldap_group_inclusion)));
-      case 130:
+      case 64:
         if (!(params.ldap_base_dn && !(0, _utils.isString)(params.ldap_base_dn))) {
-          _context3.next = 132;
+          _context3.next = 65;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_base_dn must be of type String, received ".concat((0, _utils.getType)(params.ldap_base_dn)));
-      case 132:
+      case 65:
         if (!(params.ldap_password_change && !(0, _utils.isString)(params.ldap_password_change))) {
-          _context3.next = 134;
+          _context3.next = 66;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_password_change must be of type String, received ".concat((0, _utils.getType)(params.ldap_password_change)));
-      case 134:
+      case 66:
         if (!(params.ldap_password_change_confirmation && !(0, _utils.isString)(params.ldap_password_change_confirmation))) {
-          _context3.next = 136;
+          _context3.next = 67;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: ldap_password_change_confirmation must be of type String, received ".concat((0, _utils.getType)(params.ldap_password_change_confirmation)));
-      case 136:
+      case 67:
         if (!(params.smtp_password && !(0, _utils.isString)(params.smtp_password))) {
-          _context3.next = 138;
+          _context3.next = 68;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: smtp_password must be of type String, received ".concat((0, _utils.getType)(params.smtp_password)));
-      case 138:
+      case 68:
         if (!(params.session_expiry_minutes && !(0, _utils.isInt)(params.session_expiry_minutes))) {
-          _context3.next = 140;
+          _context3.next = 69;
           break;
         }
         throw new errors.InvalidParameterError("Bad parameter: session_expiry_minutes must be of type Int, received ".concat((0, _utils.getType)(params.session_expiry_minutes)));
-      case 140:
-        _context3.next = 142;
+      case 69:
+        _context3.next = 70;
         return _Api.default.sendRequest('/site', 'PATCH', params, options);
-      case 142:
+      case 70:
         response = _context3.sent;
         return _context3.abrupt("return", new _Site(response === null || response === void 0 ? void 0 : response.data, options));
-      case 144:
+      case 71:
       case "end":
         return _context3.stop();
     }