files.com 1.0.133 → 1.0.134

package/_VERSION

@@ -1 +1 @@
-1.0.133
+1.0.134

package/lib/models/Site.js

@@ -150,6 +150,9 @@ var Site = function Site() {
   (0, _defineProperty2.default)(this, "getDomainHstsHeader", function () {
     return _this.attributes.domain_hsts_header;
   });
+  (0, _defineProperty2.default)(this, "getDomainLetsencryptChain", function () {
+    return _this.attributes.domain_letsencrypt_chain;
+  });
   (0, _defineProperty2.default)(this, "getEmail", function () {
     return _this.attributes.email;
   });
@@ -515,430 +518,438 @@ var Site = function Site() {
           throw new Error("Bad parameter: domain must be of type String, received ".concat((0, _utils.getType)(domain)));
 
         case 8:
-          if (!(params['email'] && !(0, _utils.isString)(params['email']))) {
+          if (!(params['domain_letsencrypt_chain'] && !(0, _utils.isString)(params['domain_letsencrypt_chain']))) {
             _context3.next = 10;
             break;
           }
 
-          throw new Error("Bad parameter: email must be of type String, received ".concat((0, _utils.getType)(email)));
+          throw new Error("Bad parameter: domain_letsencrypt_chain must be of type String, received ".concat((0, _utils.getType)(domain_letsencrypt_chain)));
 
         case 10:
-          if (!(params['reply_to_email'] && !(0, _utils.isString)(params['reply_to_email']))) {
+          if (!(params['email'] && !(0, _utils.isString)(params['email']))) {
             _context3.next = 12;
             break;
           }
 
-          throw new Error("Bad parameter: reply_to_email must be of type String, received ".concat((0, _utils.getType)(reply_to_email)));
+          throw new Error("Bad parameter: email must be of type String, received ".concat((0, _utils.getType)(email)));
 
         case 12:
-          if (!(params['bundle_expiration'] && !(0, _utils.isInt)(params['bundle_expiration']))) {
+          if (!(params['reply_to_email'] && !(0, _utils.isString)(params['reply_to_email']))) {
             _context3.next = 14;
             break;
           }
 
-          throw new Error("Bad parameter: bundle_expiration must be of type Int, received ".concat((0, _utils.getType)(bundle_expiration)));
+          throw new Error("Bad parameter: reply_to_email must be of type String, received ".concat((0, _utils.getType)(reply_to_email)));
 
         case 14:
-          if (!(params['welcome_email_cc'] && !(0, _utils.isString)(params['welcome_email_cc']))) {
+          if (!(params['bundle_expiration'] && !(0, _utils.isInt)(params['bundle_expiration']))) {
             _context3.next = 16;
             break;
           }
 
-          throw new Error("Bad parameter: welcome_email_cc must be of type String, received ".concat((0, _utils.getType)(welcome_email_cc)));
+          throw new Error("Bad parameter: bundle_expiration must be of type Int, received ".concat((0, _utils.getType)(bundle_expiration)));
 
         case 16:
-          if (!(params['welcome_custom_text'] && !(0, _utils.isString)(params['welcome_custom_text']))) {
+          if (!(params['welcome_email_cc'] && !(0, _utils.isString)(params['welcome_email_cc']))) {
             _context3.next = 18;
             break;
           }
 
-          throw new Error("Bad parameter: welcome_custom_text must be of type String, received ".concat((0, _utils.getType)(welcome_custom_text)));
+          throw new Error("Bad parameter: welcome_email_cc must be of type String, received ".concat((0, _utils.getType)(welcome_email_cc)));
 
         case 18:
-          if (!(params['language'] && !(0, _utils.isString)(params['language']))) {
+          if (!(params['welcome_custom_text'] && !(0, _utils.isString)(params['welcome_custom_text']))) {
             _context3.next = 20;
             break;
           }
 
-          throw new Error("Bad parameter: language must be of type String, received ".concat((0, _utils.getType)(language)));
+          throw new Error("Bad parameter: welcome_custom_text must be of type String, received ".concat((0, _utils.getType)(welcome_custom_text)));
 
         case 20:
-          if (!(params['default_time_zone'] && !(0, _utils.isString)(params['default_time_zone']))) {
+          if (!(params['language'] && !(0, _utils.isString)(params['language']))) {
             _context3.next = 22;
             break;
           }
 
-          throw new Error("Bad parameter: default_time_zone must be of type String, received ".concat((0, _utils.getType)(default_time_zone)));
+          throw new Error("Bad parameter: language must be of type String, received ".concat((0, _utils.getType)(language)));
 
         case 22:
-          if (!(params['desktop_app_session_lifetime'] && !(0, _utils.isInt)(params['desktop_app_session_lifetime']))) {
+          if (!(params['default_time_zone'] && !(0, _utils.isString)(params['default_time_zone']))) {
             _context3.next = 24;
             break;
           }
 
-          throw new Error("Bad parameter: desktop_app_session_lifetime must be of type Int, received ".concat((0, _utils.getType)(desktop_app_session_lifetime)));
+          throw new Error("Bad parameter: default_time_zone must be of type String, received ".concat((0, _utils.getType)(default_time_zone)));
 
         case 24:
-          if (!(params['mobile_app_session_lifetime'] && !(0, _utils.isInt)(params['mobile_app_session_lifetime']))) {
+          if (!(params['desktop_app_session_lifetime'] && !(0, _utils.isInt)(params['desktop_app_session_lifetime']))) {
             _context3.next = 26;
             break;
           }
 
-          throw new Error("Bad parameter: mobile_app_session_lifetime must be of type Int, received ".concat((0, _utils.getType)(mobile_app_session_lifetime)));
+          throw new Error("Bad parameter: desktop_app_session_lifetime must be of type Int, received ".concat((0, _utils.getType)(desktop_app_session_lifetime)));
 
         case 26:
-          if (!(params['welcome_screen'] && !(0, _utils.isString)(params['welcome_screen']))) {
+          if (!(params['mobile_app_session_lifetime'] && !(0, _utils.isInt)(params['mobile_app_session_lifetime']))) {
             _context3.next = 28;
             break;
           }
 
-          throw new Error("Bad parameter: welcome_screen must be of type String, received ".concat((0, _utils.getType)(welcome_screen)));
+          throw new Error("Bad parameter: mobile_app_session_lifetime must be of type Int, received ".concat((0, _utils.getType)(mobile_app_session_lifetime)));
 
         case 28:
-          if (!(params['user_lockout_tries'] && !(0, _utils.isInt)(params['user_lockout_tries']))) {
+          if (!(params['welcome_screen'] && !(0, _utils.isString)(params['welcome_screen']))) {
             _context3.next = 30;
             break;
           }
 
-          throw new Error("Bad parameter: user_lockout_tries must be of type Int, received ".concat((0, _utils.getType)(user_lockout_tries)));
+          throw new Error("Bad parameter: welcome_screen must be of type String, received ".concat((0, _utils.getType)(welcome_screen)));
 
         case 30:
-          if (!(params['user_lockout_within'] && !(0, _utils.isInt)(params['user_lockout_within']))) {
+          if (!(params['user_lockout_tries'] && !(0, _utils.isInt)(params['user_lockout_tries']))) {
             _context3.next = 32;
             break;
           }
 
-          throw new Error("Bad parameter: user_lockout_within must be of type Int, received ".concat((0, _utils.getType)(user_lockout_within)));
+          throw new Error("Bad parameter: user_lockout_tries must be of type Int, received ".concat((0, _utils.getType)(user_lockout_tries)));
 
         case 32:
-          if (!(params['user_lockout_lock_period'] && !(0, _utils.isInt)(params['user_lockout_lock_period']))) {
+          if (!(params['user_lockout_within'] && !(0, _utils.isInt)(params['user_lockout_within']))) {
             _context3.next = 34;
             break;
           }
 
-          throw new Error("Bad parameter: user_lockout_lock_period must be of type Int, received ".concat((0, _utils.getType)(user_lockout_lock_period)));
+          throw new Error("Bad parameter: user_lockout_within must be of type Int, received ".concat((0, _utils.getType)(user_lockout_within)));
 
         case 34:
-          if (!(params['allowed_countries'] && !(0, _utils.isString)(params['allowed_countries']))) {
+          if (!(params['user_lockout_lock_period'] && !(0, _utils.isInt)(params['user_lockout_lock_period']))) {
             _context3.next = 36;
             break;
           }
 
-          throw new Error("Bad parameter: allowed_countries must be of type String, received ".concat((0, _utils.getType)(allowed_countries)));
+          throw new Error("Bad parameter: user_lockout_lock_period must be of type Int, received ".concat((0, _utils.getType)(user_lockout_lock_period)));
 
         case 36:
-          if (!(params['allowed_ips'] && !(0, _utils.isString)(params['allowed_ips']))) {
+          if (!(params['allowed_countries'] && !(0, _utils.isString)(params['allowed_countries']))) {
             _context3.next = 38;
             break;
           }
 
-          throw new Error("Bad parameter: allowed_ips must be of type String, received ".concat((0, _utils.getType)(allowed_ips)));
+          throw new Error("Bad parameter: allowed_countries must be of type String, received ".concat((0, _utils.getType)(allowed_countries)));
 
         case 38:
-          if (!(params['disallowed_countries'] && !(0, _utils.isString)(params['disallowed_countries']))) {
+          if (!(params['allowed_ips'] && !(0, _utils.isString)(params['allowed_ips']))) {
             _context3.next = 40;
             break;
           }
 
-          throw new Error("Bad parameter: disallowed_countries must be of type String, received ".concat((0, _utils.getType)(disallowed_countries)));
+          throw new Error("Bad parameter: allowed_ips must be of type String, received ".concat((0, _utils.getType)(allowed_ips)));
 
         case 40:
-          if (!(params['days_to_retain_backups'] && !(0, _utils.isInt)(params['days_to_retain_backups']))) {
+          if (!(params['disallowed_countries'] && !(0, _utils.isString)(params['disallowed_countries']))) {
             _context3.next = 42;
             break;
           }
 
-          throw new Error("Bad parameter: days_to_retain_backups must be of type Int, received ".concat((0, _utils.getType)(days_to_retain_backups)));
+          throw new Error("Bad parameter: disallowed_countries must be of type String, received ".concat((0, _utils.getType)(disallowed_countries)));
 
         case 42:
-          if (!(params['max_prior_passwords'] && !(0, _utils.isInt)(params['max_prior_passwords']))) {
+          if (!(params['days_to_retain_backups'] && !(0, _utils.isInt)(params['days_to_retain_backups']))) {
             _context3.next = 44;
             break;
           }
 
-          throw new Error("Bad parameter: max_prior_passwords must be of type Int, received ".concat((0, _utils.getType)(max_prior_passwords)));
+          throw new Error("Bad parameter: days_to_retain_backups must be of type Int, received ".concat((0, _utils.getType)(days_to_retain_backups)));
 
         case 44:
-          if (!(params['password_validity_days'] && !(0, _utils.isInt)(params['password_validity_days']))) {
+          if (!(params['max_prior_passwords'] && !(0, _utils.isInt)(params['max_prior_passwords']))) {
             _context3.next = 46;
             break;
           }
 
-          throw new Error("Bad parameter: password_validity_days must be of type Int, received ".concat((0, _utils.getType)(password_validity_days)));
+          throw new Error("Bad parameter: max_prior_passwords must be of type Int, received ".concat((0, _utils.getType)(max_prior_passwords)));
 
         case 46:
-          if (!(params['password_min_length'] && !(0, _utils.isInt)(params['password_min_length']))) {
+          if (!(params['password_validity_days'] && !(0, _utils.isInt)(params['password_validity_days']))) {
             _context3.next = 48;
             break;
           }
 
-          throw new Error("Bad parameter: password_min_length must be of type Int, received ".concat((0, _utils.getType)(password_min_length)));
+          throw new Error("Bad parameter: password_validity_days must be of type Int, received ".concat((0, _utils.getType)(password_validity_days)));
 
         case 48:
-          if (!(params['disable_users_from_inactivity_period_days'] && !(0, _utils.isInt)(params['disable_users_from_inactivity_period_days']))) {
+          if (!(params['password_min_length'] && !(0, _utils.isInt)(params['password_min_length']))) {
             _context3.next = 50;
             break;
           }
 
-          throw new Error("Bad parameter: disable_users_from_inactivity_period_days must be of type Int, received ".concat((0, _utils.getType)(disable_users_from_inactivity_period_days)));
+          throw new Error("Bad parameter: password_min_length must be of type Int, received ".concat((0, _utils.getType)(password_min_length)));
 
         case 50:
-          if (!(params['require_2fa_user_type'] && !(0, _utils.isString)(params['require_2fa_user_type']))) {
+          if (!(params['disable_users_from_inactivity_period_days'] && !(0, _utils.isInt)(params['disable_users_from_inactivity_period_days']))) {
             _context3.next = 52;
             break;
           }
 
-          throw new Error("Bad parameter: require_2fa_user_type must be of type String, received ".concat((0, _utils.getType)(require_2fa_user_type)));
+          throw new Error("Bad parameter: disable_users_from_inactivity_period_days must be of type Int, received ".concat((0, _utils.getType)(disable_users_from_inactivity_period_days)));
 
         case 52:
-          if (!(params['color2_top'] && !(0, _utils.isString)(params['color2_top']))) {
+          if (!(params['require_2fa_user_type'] && !(0, _utils.isString)(params['require_2fa_user_type']))) {
             _context3.next = 54;
             break;
           }
 
-          throw new Error("Bad parameter: color2_top must be of type String, received ".concat((0, _utils.getType)(color2_top)));
+          throw new Error("Bad parameter: require_2fa_user_type must be of type String, received ".concat((0, _utils.getType)(require_2fa_user_type)));
 
         case 54:
-          if (!(params['color2_left'] && !(0, _utils.isString)(params['color2_left']))) {
+          if (!(params['color2_top'] && !(0, _utils.isString)(params['color2_top']))) {
             _context3.next = 56;
             break;
           }
 
-          throw new Error("Bad parameter: color2_left must be of type String, received ".concat((0, _utils.getType)(color2_left)));
+          throw new Error("Bad parameter: color2_top must be of type String, received ".concat((0, _utils.getType)(color2_top)));
 
         case 56:
-          if (!(params['color2_link'] && !(0, _utils.isString)(params['color2_link']))) {
+          if (!(params['color2_left'] && !(0, _utils.isString)(params['color2_left']))) {
             _context3.next = 58;
             break;
           }
 
-          throw new Error("Bad parameter: color2_link must be of type String, received ".concat((0, _utils.getType)(color2_link)));
+          throw new Error("Bad parameter: color2_left must be of type String, received ".concat((0, _utils.getType)(color2_left)));
 
         case 58:
-          if (!(params['color2_text'] && !(0, _utils.isString)(params['color2_text']))) {
+          if (!(params['color2_link'] && !(0, _utils.isString)(params['color2_link']))) {
             _context3.next = 60;
             break;
           }
 
-          throw new Error("Bad parameter: color2_text must be of type String, received ".concat((0, _utils.getType)(color2_text)));
+          throw new Error("Bad parameter: color2_link must be of type String, received ".concat((0, _utils.getType)(color2_link)));
 
         case 60:
-          if (!(params['color2_top_text'] && !(0, _utils.isString)(params['color2_top_text']))) {
+          if (!(params['color2_text'] && !(0, _utils.isString)(params['color2_text']))) {
             _context3.next = 62;
             break;
           }
 
-          throw new Error("Bad parameter: color2_top_text must be of type String, received ".concat((0, _utils.getType)(color2_top_text)));
+          throw new Error("Bad parameter: color2_text must be of type String, received ".concat((0, _utils.getType)(color2_text)));
 
         case 62:
-          if (!(params['site_header'] && !(0, _utils.isString)(params['site_header']))) {
+          if (!(params['color2_top_text'] && !(0, _utils.isString)(params['color2_top_text']))) {
             _context3.next = 64;
             break;
           }
 
-          throw new Error("Bad parameter: site_header must be of type String, received ".concat((0, _utils.getType)(site_header)));
+          throw new Error("Bad parameter: color2_top_text must be of type String, received ".concat((0, _utils.getType)(color2_top_text)));
 
         case 64:
-          if (!(params['site_footer'] && !(0, _utils.isString)(params['site_footer']))) {
+          if (!(params['site_header'] && !(0, _utils.isString)(params['site_header']))) {
             _context3.next = 66;
             break;
           }
 
-          throw new Error("Bad parameter: site_footer must be of type String, received ".concat((0, _utils.getType)(site_footer)));
+          throw new Error("Bad parameter: site_header must be of type String, received ".concat((0, _utils.getType)(site_header)));
 
         case 66:
-          if (!(params['login_help_text'] && !(0, _utils.isString)(params['login_help_text']))) {
+          if (!(params['site_footer'] && !(0, _utils.isString)(params['site_footer']))) {
             _context3.next = 68;
             break;
           }
 
-          throw new Error("Bad parameter: login_help_text must be of type String, received ".concat((0, _utils.getType)(login_help_text)));
+          throw new Error("Bad parameter: site_footer must be of type String, received ".concat((0, _utils.getType)(site_footer)));
 
         case 68:
-          if (!(params['smtp_address'] && !(0, _utils.isString)(params['smtp_address']))) {
+          if (!(params['login_help_text'] && !(0, _utils.isString)(params['login_help_text']))) {
             _context3.next = 70;
             break;
           }
 
-          throw new Error("Bad parameter: smtp_address must be of type String, received ".concat((0, _utils.getType)(smtp_address)));
+          throw new Error("Bad parameter: login_help_text must be of type String, received ".concat((0, _utils.getType)(login_help_text)));
 
         case 70:
-          if (!(params['smtp_authentication'] && !(0, _utils.isString)(params['smtp_authentication']))) {
+          if (!(params['smtp_address'] && !(0, _utils.isString)(params['smtp_address']))) {
             _context3.next = 72;
             break;
           }
 
-          throw new Error("Bad parameter: smtp_authentication must be of type String, received ".concat((0, _utils.getType)(smtp_authentication)));
+          throw new Error("Bad parameter: smtp_address must be of type String, received ".concat((0, _utils.getType)(smtp_address)));
 
         case 72:
-          if (!(params['smtp_from'] && !(0, _utils.isString)(params['smtp_from']))) {
+          if (!(params['smtp_authentication'] && !(0, _utils.isString)(params['smtp_authentication']))) {
             _context3.next = 74;
             break;
           }
 
-          throw new Error("Bad parameter: smtp_from must be of type String, received ".concat((0, _utils.getType)(smtp_from)));
+          throw new Error("Bad parameter: smtp_authentication must be of type String, received ".concat((0, _utils.getType)(smtp_authentication)));
 
         case 74:
-          if (!(params['smtp_username'] && !(0, _utils.isString)(params['smtp_username']))) {
+          if (!(params['smtp_from'] && !(0, _utils.isString)(params['smtp_from']))) {
             _context3.next = 76;
             break;
           }
 
-          throw new Error("Bad parameter: smtp_username must be of type String, received ".concat((0, _utils.getType)(smtp_username)));
+          throw new Error("Bad parameter: smtp_from must be of type String, received ".concat((0, _utils.getType)(smtp_from)));
 
         case 76:
-          if (!(params['smtp_port'] && !(0, _utils.isInt)(params['smtp_port']))) {
+          if (!(params['smtp_username'] && !(0, _utils.isString)(params['smtp_username']))) {
             _context3.next = 78;
             break;
           }
 
-          throw new Error("Bad parameter: smtp_port must be of type Int, received ".concat((0, _utils.getType)(smtp_port)));
+          throw new Error("Bad parameter: smtp_username must be of type String, received ".concat((0, _utils.getType)(smtp_username)));
 
         case 78:
-          if (!(params['ldap_type'] && !(0, _utils.isString)(params['ldap_type']))) {
+          if (!(params['smtp_port'] && !(0, _utils.isInt)(params['smtp_port']))) {
             _context3.next = 80;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_type must be of type String, received ".concat((0, _utils.getType)(ldap_type)));
+          throw new Error("Bad parameter: smtp_port must be of type Int, received ".concat((0, _utils.getType)(smtp_port)));
 
         case 80:
-          if (!(params['ldap_host'] && !(0, _utils.isString)(params['ldap_host']))) {
+          if (!(params['ldap_type'] && !(0, _utils.isString)(params['ldap_type']))) {
             _context3.next = 82;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_host must be of type String, received ".concat((0, _utils.getType)(ldap_host)));
+          throw new Error("Bad parameter: ldap_type must be of type String, received ".concat((0, _utils.getType)(ldap_type)));
 
         case 82:
-          if (!(params['ldap_host_2'] && !(0, _utils.isString)(params['ldap_host_2']))) {
+          if (!(params['ldap_host'] && !(0, _utils.isString)(params['ldap_host']))) {
             _context3.next = 84;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_host_2 must be of type String, received ".concat((0, _utils.getType)(ldap_host_2)));
+          throw new Error("Bad parameter: ldap_host must be of type String, received ".concat((0, _utils.getType)(ldap_host)));
 
         case 84:
-          if (!(params['ldap_host_3'] && !(0, _utils.isString)(params['ldap_host_3']))) {
+          if (!(params['ldap_host_2'] && !(0, _utils.isString)(params['ldap_host_2']))) {
             _context3.next = 86;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_host_3 must be of type String, received ".concat((0, _utils.getType)(ldap_host_3)));
+          throw new Error("Bad parameter: ldap_host_2 must be of type String, received ".concat((0, _utils.getType)(ldap_host_2)));
 
         case 86:
-          if (!(params['ldap_port'] && !(0, _utils.isInt)(params['ldap_port']))) {
+          if (!(params['ldap_host_3'] && !(0, _utils.isString)(params['ldap_host_3']))) {
             _context3.next = 88;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_port must be of type Int, received ".concat((0, _utils.getType)(ldap_port)));
+          throw new Error("Bad parameter: ldap_host_3 must be of type String, received ".concat((0, _utils.getType)(ldap_host_3)));
 
         case 88:
-          if (!(params['ldap_username'] && !(0, _utils.isString)(params['ldap_username']))) {
+          if (!(params['ldap_port'] && !(0, _utils.isInt)(params['ldap_port']))) {
             _context3.next = 90;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_username must be of type String, received ".concat((0, _utils.getType)(ldap_username)));
+          throw new Error("Bad parameter: ldap_port must be of type Int, received ".concat((0, _utils.getType)(ldap_port)));
 
         case 90:
-          if (!(params['ldap_username_field'] && !(0, _utils.isString)(params['ldap_username_field']))) {
+          if (!(params['ldap_username'] && !(0, _utils.isString)(params['ldap_username']))) {
             _context3.next = 92;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_username_field must be of type String, received ".concat((0, _utils.getType)(ldap_username_field)));
+          throw new Error("Bad parameter: ldap_username must be of type String, received ".concat((0, _utils.getType)(ldap_username)));
 
         case 92:
-          if (!(params['ldap_domain'] && !(0, _utils.isString)(params['ldap_domain']))) {
+          if (!(params['ldap_username_field'] && !(0, _utils.isString)(params['ldap_username_field']))) {
             _context3.next = 94;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_domain must be of type String, received ".concat((0, _utils.getType)(ldap_domain)));
+          throw new Error("Bad parameter: ldap_username_field must be of type String, received ".concat((0, _utils.getType)(ldap_username_field)));
 
         case 94:
-          if (!(params['ldap_user_action'] && !(0, _utils.isString)(params['ldap_user_action']))) {
+          if (!(params['ldap_domain'] && !(0, _utils.isString)(params['ldap_domain']))) {
             _context3.next = 96;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_user_action must be of type String, received ".concat((0, _utils.getType)(ldap_user_action)));
+          throw new Error("Bad parameter: ldap_domain must be of type String, received ".concat((0, _utils.getType)(ldap_domain)));
 
         case 96:
-          if (!(params['ldap_group_action'] && !(0, _utils.isString)(params['ldap_group_action']))) {
+          if (!(params['ldap_user_action'] && !(0, _utils.isString)(params['ldap_user_action']))) {
             _context3.next = 98;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_group_action must be of type String, received ".concat((0, _utils.getType)(ldap_group_action)));
+          throw new Error("Bad parameter: ldap_user_action must be of type String, received ".concat((0, _utils.getType)(ldap_user_action)));
 
         case 98:
-          if (!(params['ldap_user_include_groups'] && !(0, _utils.isString)(params['ldap_user_include_groups']))) {
+          if (!(params['ldap_group_action'] && !(0, _utils.isString)(params['ldap_group_action']))) {
             _context3.next = 100;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_user_include_groups must be of type String, received ".concat((0, _utils.getType)(ldap_user_include_groups)));
+          throw new Error("Bad parameter: ldap_group_action must be of type String, received ".concat((0, _utils.getType)(ldap_group_action)));
 
         case 100:
-          if (!(params['ldap_group_exclusion'] && !(0, _utils.isString)(params['ldap_group_exclusion']))) {
+          if (!(params['ldap_user_include_groups'] && !(0, _utils.isString)(params['ldap_user_include_groups']))) {
             _context3.next = 102;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_group_exclusion must be of type String, received ".concat((0, _utils.getType)(ldap_group_exclusion)));
+          throw new Error("Bad parameter: ldap_user_include_groups must be of type String, received ".concat((0, _utils.getType)(ldap_user_include_groups)));
 
         case 102:
-          if (!(params['ldap_group_inclusion'] && !(0, _utils.isString)(params['ldap_group_inclusion']))) {
+          if (!(params['ldap_group_exclusion'] && !(0, _utils.isString)(params['ldap_group_exclusion']))) {
             _context3.next = 104;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_group_inclusion must be of type String, received ".concat((0, _utils.getType)(ldap_group_inclusion)));
+          throw new Error("Bad parameter: ldap_group_exclusion must be of type String, received ".concat((0, _utils.getType)(ldap_group_exclusion)));
 
         case 104:
-          if (!(params['ldap_base_dn'] && !(0, _utils.isString)(params['ldap_base_dn']))) {
+          if (!(params['ldap_group_inclusion'] && !(0, _utils.isString)(params['ldap_group_inclusion']))) {
             _context3.next = 106;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_base_dn must be of type String, received ".concat((0, _utils.getType)(ldap_base_dn)));
+          throw new Error("Bad parameter: ldap_group_inclusion must be of type String, received ".concat((0, _utils.getType)(ldap_group_inclusion)));
 
         case 106:
-          if (!(params['ldap_password_change'] && !(0, _utils.isString)(params['ldap_password_change']))) {
+          if (!(params['ldap_base_dn'] && !(0, _utils.isString)(params['ldap_base_dn']))) {
             _context3.next = 108;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_password_change must be of type String, received ".concat((0, _utils.getType)(ldap_password_change)));
+          throw new Error("Bad parameter: ldap_base_dn must be of type String, received ".concat((0, _utils.getType)(ldap_base_dn)));
 
         case 108:
-          if (!(params['ldap_password_change_confirmation'] && !(0, _utils.isString)(params['ldap_password_change_confirmation']))) {
+          if (!(params['ldap_password_change'] && !(0, _utils.isString)(params['ldap_password_change']))) {
             _context3.next = 110;
             break;
           }
 
-          throw new Error("Bad parameter: ldap_password_change_confirmation must be of type String, received ".concat((0, _utils.getType)(ldap_password_change_confirmation)));
+          throw new Error("Bad parameter: ldap_password_change must be of type String, received ".concat((0, _utils.getType)(ldap_password_change)));
 
         case 110:
-          if (!(params['smtp_password'] && !(0, _utils.isString)(params['smtp_password']))) {
+          if (!(params['ldap_password_change_confirmation'] && !(0, _utils.isString)(params['ldap_password_change_confirmation']))) {
             _context3.next = 112;
             break;
           }
 
-          throw new Error("Bad parameter: smtp_password must be of type String, received ".concat((0, _utils.getType)(smtp_password)));
+          throw new Error("Bad parameter: ldap_password_change_confirmation must be of type String, received ".concat((0, _utils.getType)(ldap_password_change_confirmation)));
 
         case 112:
-          _context3.next = 114;
-          return _Api.default.sendRequest("/site", 'PATCH', params, options);
+          if (!(params['smtp_password'] && !(0, _utils.isString)(params['smtp_password']))) {
+            _context3.next = 114;
+            break;
+          }
+
+          throw new Error("Bad parameter: smtp_password must be of type String, received ".concat((0, _utils.getType)(smtp_password)));
 
         case 114:
+          _context3.next = 116;
+          return _Api.default.sendRequest("/site", 'PATCH', params, options);
+
+        case 116:
           response = _context3.sent;
           return _context3.abrupt("return", new Site(response === null || response === void 0 ? void 0 : response.data, options));
 
-        case 116:
+        case 118:
         case "end":
           return _context3.stop();
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "files.com",
-  "version": "1.0.133",
+  "version": "1.0.134",
   "description": "Files.com SDK for JavaScript",
   "keywords": [
     "files.com",

package/src/models/Site.js

@@ -133,6 +133,9 @@ class Site {
   // boolean # Send HSTS (HTTP Strict Transport Security) header when visitors access the site via a custom domain?
   getDomainHstsHeader = () => this.attributes.domain_hsts_header
 
+  // string # Letsencrypt chain to use when registering SSL Certificate for domain.
+  getDomainLetsencryptChain = () => this.attributes.domain_letsencrypt_chain
+
   // email # Main email for this site
   getEmail = () => this.attributes.email
 
@@ -415,6 +418,7 @@ class Site {
   //   subdomain - string - Site subdomain
   //   domain - string - Custom domain
   //   domain_hsts_header - boolean - Send HSTS (HTTP Strict Transport Security) header when visitors access the site via a custom domain?
+  //   domain_letsencrypt_chain - string - Letsencrypt chain to use when registering SSL Certificate for domain.
   //   email - string - Main email for this site
   //   reply_to_email - string - Reply-to email for this site
   //   allow_bundle_names - boolean - Are manual Bundle names allowed?
@@ -539,6 +543,10 @@ class Site {
       throw new Error(`Bad parameter: domain must be of type String, received ${getType(domain)}`)
     }
 
+    if (params['domain_letsencrypt_chain'] && !isString(params['domain_letsencrypt_chain'])) {
+      throw new Error(`Bad parameter: domain_letsencrypt_chain must be of type String, received ${getType(domain_letsencrypt_chain)}`)
+    }
+
     if (params['email'] && !isString(params['email'])) {
       throw new Error(`Bad parameter: email must be of type String, received ${getType(email)}`)
     }