files.com 1.1.669 → 1.1.671

data/lib/files.com/models/two_factor_authentication_method.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Files
+  class TwoFactorAuthenticationMethod
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - 2fa ID
+    def id
+      @attributes[:id]
+    end
+
+    def id=(value)
+      @attributes[:id] = value
+    end
+
+    # string - 2fa method name
+    def name
+      @attributes[:name]
+    end
+
+    def name=(value)
+      @attributes[:name] = value
+    end
+
+    # string - Type of 2fa
+    def method_type
+      @attributes[:method_type]
+    end
+
+    def method_type=(value)
+      @attributes[:method_type] = value
+    end
+
+    # string - 2fa phone number (if SMS)
+    def phone_number
+      @attributes[:phone_number]
+    end
+
+    def phone_number=(value)
+      @attributes[:phone_number] = value
+    end
+
+    # string - 2fa phone number country (if SMS)
+    def phone_number_country
+      @attributes[:phone_number_country]
+    end
+
+    def phone_number_country=(value)
+      @attributes[:phone_number_country] = value
+    end
+
+    # string - 2fa phone number national format (if SMS)
+    def phone_number_national_format
+      @attributes[:phone_number_national_format]
+    end
+
+    def phone_number_national_format=(value)
+      @attributes[:phone_number_national_format] = value
+    end
+
+    # array(string) - For the Static method type, this is the list of tokens which can be used
+    def secret_tokens
+      @attributes[:secret_tokens]
+    end
+
+    def secret_tokens=(value)
+      @attributes[:secret_tokens] = value
+    end
+
+    # boolean - 2fa setup expired?
+    def setup_expired
+      @attributes[:setup_expired]
+    end
+
+    def setup_expired=(value)
+      @attributes[:setup_expired] = value
+    end
+
+    # boolean - 2fa setup complete?
+    def setup_complete
+      @attributes[:setup_complete]
+    end
+
+    def setup_complete=(value)
+      @attributes[:setup_complete] = value
+    end
+
+    # date-time - 2fa setup expires at this date/time (typically 10 minutes after a new method is created)
+    def setup_expires_at
+      @attributes[:setup_expires_at]
+    end
+
+    def setup_expires_at=(value)
+      @attributes[:setup_expires_at] = value
+    end
+
+    # string - TOTP provisioning URI (if TOTP)
+    def totp_provisioning_uri
+      @attributes[:totp_provisioning_uri]
+    end
+
+    def totp_provisioning_uri=(value)
+      @attributes[:totp_provisioning_uri] = value
+    end
+
+    # object - WebAuthn / FIDO 2 registration options (if WebAuthn)
+    def webauthn_registration_options
+      @attributes[:webauthn_registration_options]
+    end
+
+    def webauthn_registration_options=(value)
+      @attributes[:webauthn_registration_options] = value
+    end
+
+    # boolean - Set true to skip checking this 2FA method when using FTP, SFTP, and DAV
+    def bypass_for_ftp_sftp_dav
+      @attributes[:bypass_for_ftp_sftp_dav]
+    end
+
+    def bypass_for_ftp_sftp_dav=(value)
+      @attributes[:bypass_for_ftp_sftp_dav] = value
+    end
+
+    # string - Current value of OTP, Yubikey string, or Webauthn response value.
+    def otp
+      @attributes[:otp]
+    end
+
+    def otp=(value)
+      @attributes[:otp] = value
+    end
+
+    # Parameters:
+    #   otp - string - Current value of OTP, Yubikey string, or Webauthn response value.
+    #   name - string - 2fa method name
+    #   bypass_for_ftp_sftp_dav - boolean - Set true to skip checking this 2FA method when using FTP, SFTP, and DAV
+    def update(params = {})
+      params ||= {}
+      params[:id] = @attributes[:id]
+      raise MissingParameterError.new("Current object doesn't have a id") unless @attributes[:id]
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params[:id] and !params[:id].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: otp must be an String") if params[:otp] and !params[:otp].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: name must be an String") if params[:name] and !params[:name].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: id") unless params[:id]
+
+      Api.send_request("/2fa/#{@attributes[:id]}", :patch, params, @options)
+    end
+
+    def delete(params = {})
+      params ||= {}
+      params[:id] = @attributes[:id]
+      raise MissingParameterError.new("Current object doesn't have a id") unless @attributes[:id]
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params[:id] and !params[:id].is_a?(Integer)
+      raise MissingParameterError.new("Parameter missing: id") unless params[:id]
+
+      Api.send_request("/2fa/#{@attributes[:id]}", :delete, params, @options)
+    end
+
+    def destroy(params = {})
+      delete(params)
+      nil
+    end
+
+    def save
+      if @attributes[:id]
+        new_obj = update(@attributes)
+      else
+        new_obj = TwoFactorAuthenticationMethod.create(@attributes, @options)
+      end
+
+      @attributes = new_obj.attributes
+      true
+    end
+
+    # Parameters:
+    #   cursor - string - Used for pagination.  When a list request has more records available, cursors are provided in the response headers `X-Files-Cursor-Next` and `X-Files-Cursor-Prev`.  Send one of those cursor value here to resume an existing list from the next available record.  Note: many of our SDKs have iterator methods that will automatically handle cursor-based pagination.
+    #   per_page - int64 - Number of records to show per page.  (Max: 10000, 1,000 or less is recommended).
+    def self.get(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: cursor must be an String") if params[:cursor] and !params[:cursor].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: per_page must be an Integer") if params[:per_page] and !params[:per_page].is_a?(Integer)
+
+      List.new(TwoFactorAuthenticationMethod, params) do
+        Api.send_request("/2fa", :get, params, options)
+      end
+    end
+
+    # Parameters:
+    #   method_type (required) - string - Type of 2fa
+    #   name - string - 2fa method name
+    #   phone_number - string - 2fa phone number (if SMS)
+    #   bypass_for_ftp_sftp_dav - boolean - Set true to skip checking this 2FA method when using FTP, SFTP, and DAV
+    def self.create(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: method_type must be an String") if params[:method_type] and !params[:method_type].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: name must be an String") if params[:name] and !params[:name].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: phone_number must be an String") if params[:phone_number] and !params[:phone_number].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: method_type") unless params[:method_type]
+
+      response, options = Api.send_request("/2fa", :post, params, options)
+      TwoFactorAuthenticationMethod.new(response.data, options)
+    end
+
+    # Parameters:
+    #   webauthn_only - boolean - Set to `true` to only generate an OTP for Webauthn keys and skip things like SMS.
+    def self.send_code(params = {}, options = {})
+      response, options = Api.send_request("/2fa/send_code", :post, params, options)
+      WebauthnSignRequest.new(response.data, options)
+    end
+
+    def self.create_export(params = {}, options = {})
+      response, options = Api.send_request("/2fa/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
+    # Parameters:
+    #   otp - string - Current value of OTP, Yubikey string, or Webauthn response value.
+    #   name - string - 2fa method name
+    #   bypass_for_ftp_sftp_dav - boolean - Set true to skip checking this 2FA method when using FTP, SFTP, and DAV
+    def self.update(id, params = {}, options = {})
+      params ||= {}
+      params[:id] = id
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params[:id] and !params[:id].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: otp must be an String") if params[:otp] and !params[:otp].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: name must be an String") if params[:name] and !params[:name].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: id") unless params[:id]
+
+      response, options = Api.send_request("/2fa/#{params[:id]}", :patch, params, options)
+      TwoFactorAuthenticationMethod.new(response.data, options)
+    end
+
+    def self.delete(id, params = {}, options = {})
+      params ||= {}
+      params[:id] = id
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params[:id] and !params[:id].is_a?(Integer)
+      raise MissingParameterError.new("Parameter missing: id") unless params[:id]
+
+      Api.send_request("/2fa/#{params[:id]}", :delete, params, options)
+      nil
+    end
+
+    def self.destroy(id, params = {}, options = {})
+      delete(id, params, options)
+      nil
+    end
+  end
+end

data/lib/files.com/models/usage_daily_snapshot.rb

@@ -96,5 +96,24 @@ module Files
     def self.all(params = {}, options = {})
       list(params, options)
     end
+
+    # Parameters:
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `date`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `date` and `usage_snapshot_id`. Valid field combinations are `[ usage_snapshot_id, date ]`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `date`.
+    #   filter_gteq - object - If set, return records where the specified field is greater than or equal the supplied value. Valid fields are `date`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `date`.
+    #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `date`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gt must be an Hash") if params[:filter_gt] and !params[:filter_gt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gteq must be an Hash") if params[:filter_gteq] and !params[:filter_gteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+
+      response, options = Api.send_request("/usage_daily_snapshots/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

data/lib/files.com/models/usage_snapshot.rb

@@ -99,5 +99,10 @@ module Files
     def self.all(params = {}, options = {})
       list(params, options)
     end
+
+    def self.create_export(params = {}, options = {})
+      response, options = Api.send_request("/usage_snapshots/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

data/lib/files.com/models/user.rb

@@ -734,6 +734,11 @@ module Files
       @attributes[:type_of_2fa_for_display] = value
     end
 
+    # date-time - When this user was updated.  Used only for ExaVault compatibility API.  Do not use for other purposes, as this value reveals information about internal changes to users that isn't necessarily public.
+    def updated_at
+      @attributes[:updated_at]
+    end
+
     # string - Root folder for FTP (and optionally SFTP if the appropriate site-wide setting is set).  Note that this is not used for API, Desktop, or Web interface.
     def user_root
       @attributes[:user_root]
@@ -770,6 +775,15 @@ module Files
       @attributes[:password_expire_at] = value
     end
 
+    # boolean - Does this user have any associations that can be reassigned on delete?
+    def has_reassignable_associations
+      @attributes[:has_reassignable_associations]
+    end
+
+    def has_reassignable_associations=(value)
+      @attributes[:has_reassignable_associations] = value
+    end
+
     # file - An image file for your user avatar.
     def avatar_file
       @attributes[:avatar_file]
@@ -1063,8 +1077,16 @@ module Files
     #   filter_prefix - object - If set, return records where the specified field is prefixed by the supplied value. Valid fields are `username`, `name`, `email` or `company`. Valid field combinations are `[ company, name ]`.
     #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `password_validity_days`, `last_login_at` or `authenticate_until`.
     #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `password_validity_days`, `last_login_at` or `authenticate_until`.
+    #   action - string - Set to `count` to return a count of results rather than the actual results.
     #   ids - string - comma-separated list of User IDs
     #   include_parent_site_users - boolean - Include users from the parent site.
+    #   q[username] - string - List users matching username.
+    #   q[email] - string - List users matching email.
+    #   q[notes] - string - List users matching notes field.
+    #   q[admin] - string - If `true`, list only admin users.
+    #   q[allowed_ips] - string - If set, list only users with overridden allowed IP setting.
+    #   q[password_validity_days] - string - If set, list only users with overridden password validity days setting.
+    #   q[ssl_required] - string - If set, list only users with overridden SSL required setting.
     #   search - string - Searches for partial matches of name, username, or email.
     def self.list(params = {}, options = {})
       raise InvalidParameterError.new("Bad parameter: cursor must be an String") if params[:cursor] and !params[:cursor].is_a?(String)
@@ -1076,6 +1098,7 @@ module Files
       raise InvalidParameterError.new("Bad parameter: filter_prefix must be an Hash") if params[:filter_prefix] and !params[:filter_prefix].is_a?(Hash)
       raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
       raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: action must be an String") if params[:action] and !params[:action].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: ids must be an String") if params[:ids] and !params[:ids].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: search must be an String") if params[:search] and !params[:search].is_a?(String)
 
@@ -1090,6 +1113,7 @@ module Files
 
     # Parameters:
     #   id (required) - int64 - User ID.
+    #   include_reassignable_associations - boolean - If true includes has_reassignable_associations in the response.
     def self.find(id, params = {}, options = {})
       params ||= {}
       params[:id] = id
@@ -1245,6 +1269,41 @@ module Files
       nil
     end
 
+    # Parameters:
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `site_id`, `workspace_id`, `company`, `name`, `disabled`, `authenticate_until`, `username`, `email`, `site_admin`, `last_desktop_login_at`, `last_login_at`, `password_validity_days` or `ssl_required`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `username`, `name`, `email`, `company`, `site_admin`, `password_validity_days`, `ssl_required`, `last_login_at`, `authenticate_until`, `not_site_admin`, `disabled`, `partner_id`, `primary_group_id` or `workspace_id`. Valid field combinations are `[ site_admin, username ]`, `[ not_site_admin, username ]`, `[ workspace_id, username ]`, `[ company, name ]`, `[ workspace_id, name ]`, `[ workspace_id, email ]`, `[ workspace_id, company ]`, `[ workspace_id, site_admin ]`, `[ workspace_id, not_site_admin ]`, `[ workspace_id, disabled ]`, `[ workspace_id, partner_id ]`, `[ workspace_id, site_admin, username ]`, `[ workspace_id, not_site_admin, username ]`, `[ workspace_id, disabled, username ]`, `[ workspace_id, partner_id, username ]` or `[ workspace_id, company, name ]`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `password_validity_days`, `last_login_at` or `authenticate_until`.
+    #   filter_gteq - object - If set, return records where the specified field is greater than or equal the supplied value. Valid fields are `password_validity_days`, `last_login_at` or `authenticate_until`.
+    #   filter_prefix - object - If set, return records where the specified field is prefixed by the supplied value. Valid fields are `username`, `name`, `email` or `company`. Valid field combinations are `[ company, name ]`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `password_validity_days`, `last_login_at` or `authenticate_until`.
+    #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `password_validity_days`, `last_login_at` or `authenticate_until`.
+    #   action - string - Set to `count` to return a count of results rather than the actual results.
+    #   ids - string - comma-separated list of User IDs
+    #   include_parent_site_users - boolean - Include users from the parent site.
+    #   q[username] - string - List users matching username.
+    #   q[email] - string - List users matching email.
+    #   q[notes] - string - List users matching notes field.
+    #   q[admin] - string - If `true`, list only admin users.
+    #   q[allowed_ips] - string - If set, list only users with overridden allowed IP setting.
+    #   q[password_validity_days] - string - If set, list only users with overridden password validity days setting.
+    #   q[ssl_required] - string - If set, list only users with overridden SSL required setting.
+    #   search - string - Searches for partial matches of name, username, or email.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gt must be an Hash") if params[:filter_gt] and !params[:filter_gt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gteq must be an Hash") if params[:filter_gteq] and !params[:filter_gteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_prefix must be an Hash") if params[:filter_prefix] and !params[:filter_prefix].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: action must be an String") if params[:action] and !params[:action].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: ids must be an String") if params[:ids] and !params[:ids].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: search must be an String") if params[:search] and !params[:search].is_a?(String)
+
+      response, options = Api.send_request("/users/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   avatar_file - file - An image file for your user avatar.
     #   avatar_delete - boolean - If true, the avatar will be deleted.

data/lib/files.com/models/user_cipher_use.rb

@@ -78,5 +78,26 @@ module Files
     def self.all(params = {}, options = {})
       list(params, options)
     end
+
+    # Parameters:
+    #   user_id - int64 - User ID. If provided, will return uses for this user.
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `updated_at`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `insecure` and `updated_at`. Valid field combinations are `[ insecure, updated_at ]`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `updated_at`.
+    #   filter_gteq - object - If set, return records where the specified field is greater than or equal the supplied value. Valid fields are `updated_at`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `updated_at`.
+    #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `updated_at`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: user_id must be an Integer") if params[:user_id] and !params[:user_id].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gt must be an Hash") if params[:filter_gt] and !params[:filter_gt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gteq must be an Hash") if params[:filter_gteq] and !params[:filter_gteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+
+      response, options = Api.send_request("/user_cipher_uses/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

data/lib/files.com/models/user_lifecycle_rule.rb

@@ -268,6 +268,17 @@ module Files
       UserLifecycleRule.new(response.data, options)
     end
 
+    # Parameters:
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `site_id` and `workspace_id`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `workspace_id`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+
+      response, options = Api.send_request("/user_lifecycle_rules/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   action - string - Action to take on inactive users (disable or delete)
     #   apply_to_all_workspaces - boolean - If true, a default-workspace rule also applies to users in all workspaces.

data/lib/files.com/models/user_request.rb

@@ -130,6 +130,11 @@ module Files
       UserRequest.new(response.data, options)
     end
 
+    def self.create_export(params = {}, options = {})
+      response, options = Api.send_request("/user_requests/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     def self.delete(id, params = {}, options = {})
       params ||= {}
       params[:id] = id

data/lib/files.com/models/user_security_event.rb

@@ -87,5 +87,24 @@ module Files
     def self.get(id, params = {}, options = {})
       find(id, params, options)
     end
+
+    # Parameters:
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `created_at` and `user_id`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `created_at` and `user_id`. Valid field combinations are `[ user_id, created_at ]`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `created_at`.
+    #   filter_gteq - object - If set, return records where the specified field is greater than or equal the supplied value. Valid fields are `created_at`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `created_at`.
+    #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `created_at`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gt must be an Hash") if params[:filter_gt] and !params[:filter_gt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gteq must be an Hash") if params[:filter_gteq] and !params[:filter_gteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+
+      response, options = Api.send_request("/user_security_events/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

data/lib/files.com/models/user_sftp_client_use.rb

@@ -51,5 +51,14 @@ module Files
     def self.all(params = {}, options = {})
       list(params, options)
     end
+
+    # Parameters:
+    #   user_id - int64 - User ID. If provided, will return uses for this user.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: user_id must be an Integer") if params[:user_id] and !params[:user_id].is_a?(Integer)
+
+      response, options = Api.send_request("/user_sftp_client_uses/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

data/lib/files.com/models/warning.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Files
+  class Warning
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # array(object) - A list of warnings
+    def warnings
+      @attributes[:warnings]
+    end
+
+    # Parameters:
+    #   cursor - string - Used for pagination.  When a list request has more records available, cursors are provided in the response headers `X-Files-Cursor-Next` and `X-Files-Cursor-Prev`.  Send one of those cursor value here to resume an existing list from the next available record.  Note: many of our SDKs have iterator methods that will automatically handle cursor-based pagination.
+    #   per_page - int64 - Number of records to show per page.  (Max: 10000, 1,000 or less is recommended).
+    def self.list(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: cursor must be an String") if params[:cursor] and !params[:cursor].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: per_page must be an Integer") if params[:per_page] and !params[:per_page].is_a?(Integer)
+
+      List.new(Warning, params) do
+        Api.send_request("/warnings", :get, params, options)
+      end
+    end
+
+    def self.all(params = {}, options = {})
+      list(params, options)
+    end
+
+    def self.create_export(params = {}, options = {})
+      response, options = Api.send_request("/warnings/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+  end
+end