files.com 1.1.669 → 1.1.671

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

@@ -178,6 +178,11 @@ module Files
       ChildSiteManagementPolicy.new(response.data, options)
     end
 
+    def self.create_export(params = {}, options = {})
+      response, options = Api.send_request("/child_site_management_policies/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   value - object - Policy configuration data. Attributes differ by policy type. For more information, refer to the Value Hash section of the developer documentation.
     #   skip_child_site_ids - array(int64) - IDs of child sites that this policy has been exempted from. If `skip_child_site_ids` is empty, the policy will be applied to all child sites. To apply a policy to a child site that has been exempted, remove it from `skip_child_site_ids` or set it to an empty array (`[]`).

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

@@ -161,6 +161,15 @@ module Files
       Clickwrap.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 .
+    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)
+
+      response, options = Api.send_request("/clickwraps/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   name - string - Name of the Clickwrap agreement (used when selecting from multiple Clickwrap agreements.)
     #   body - string - Body text of Clickwrap (supports Markdown formatting).

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Files
+  class ClickwrapAcceptance
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - Clickwrap Acceptance ID
+    def id
+      @attributes[:id]
+    end
+
+    def id=(value)
+      @attributes[:id] = value
+    end
+
+    # int64 - Clickwrap ID
+    def clickwrap_id
+      @attributes[:clickwrap_id]
+    end
+
+    def clickwrap_id=(value)
+      @attributes[:clickwrap_id] = value
+    end
+
+    # date-time - Acceptance timestamp
+    def created_at
+      @attributes[:created_at]
+    end
+
+    def save
+      if @attributes[:id]
+        raise NotImplementedError.new("The ClickwrapAcceptance object doesn't support updates.")
+      else
+        new_obj = ClickwrapAcceptance.create(@attributes, @options)
+      end
+
+      @attributes = new_obj.attributes
+      true
+    end
+
+    # Parameters:
+    #   clickwrap_id (required) - int64
+    def self.create(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: clickwrap_id must be an Integer") if params[:clickwrap_id] and !params[:clickwrap_id].is_a?(Integer)
+      raise MissingParameterError.new("Parameter missing: clickwrap_id") unless params[:clickwrap_id]
+
+      response, options = Api.send_request("/clickwrap_acceptances", :post, params, options)
+      ClickwrapAcceptance.new(response.data, options)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Files
+  class ClientLog
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # Parameters:
+    #   identifier (required) - string - Client log stream identifier
+    #   body (required) - string - NDJSON log records
+    def self.log(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: identifier must be an String") if params[:identifier] and !params[:identifier].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: body must be an String") if params[:body] and !params[:body].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: identifier") unless params[:identifier]
+      raise MissingParameterError.new("Parameter missing: body") unless params[:body]
+
+      Api.send_request("/client_logs/log", :post, params, options)
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Files
+  class CrashReport
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - Crash Report ID
+    def id
+      @attributes[:id]
+    end
+
+    def id=(value)
+      @attributes[:id] = value
+    end
+
+    # string
+    def build
+      @attributes[:build]
+    end
+
+    def build=(value)
+      @attributes[:build] = value
+    end
+
+    # string
+    def platform
+      @attributes[:platform]
+    end
+
+    def platform=(value)
+      @attributes[:platform] = value
+    end
+
+    # string
+    def product_name
+      @attributes[:product_name]
+    end
+
+    def product_name=(value)
+      @attributes[:product_name] = value
+    end
+
+    # string
+    def version
+      @attributes[:version]
+    end
+
+    def version=(value)
+      @attributes[:version] = value
+    end
+
+    # string
+    def comment
+      @attributes[:comment]
+    end
+
+    def comment=(value)
+      @attributes[:comment] = value
+    end
+
+    # string
+    def email
+      @attributes[:email]
+    end
+
+    def email=(value)
+      @attributes[:email] = value
+    end
+
+    # string
+    def platform_version
+      @attributes[:platform_version]
+    end
+
+    def platform_version=(value)
+      @attributes[:platform_version] = value
+    end
+
+    # string
+    def release_channel
+      @attributes[:release_channel]
+    end
+
+    def release_channel=(value)
+      @attributes[:release_channel] = value
+    end
+
+    # file
+    def dump_file
+      @attributes[:dump_file]
+    end
+
+    def dump_file=(value)
+      @attributes[:dump_file] = value
+    end
+
+    # file
+    def log_file
+      @attributes[:log_file]
+    end
+
+    def log_file=(value)
+      @attributes[:log_file] = value
+    end
+
+    def save
+      if @attributes[:id]
+        raise NotImplementedError.new("The CrashReport object doesn't support updates.")
+      else
+        new_obj = CrashReport.create(@attributes, @options)
+      end
+
+      @attributes = new_obj.attributes
+      true
+    end
+
+    # Parameters:
+    #   build (required) - string
+    #   platform (required) - string
+    #   product_name (required) - string
+    #   version (required) - string
+    #   comment - string
+    #   email - string
+    #   platform_version - string
+    #   release_channel - string
+    #   dump_file - file
+    #   log_file - file
+    def self.create(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: build must be an String") if params[:build] and !params[:build].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: platform must be an String") if params[:platform] and !params[:platform].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: product_name must be an String") if params[:product_name] and !params[:product_name].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: version must be an String") if params[:version] and !params[:version].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: comment must be an String") if params[:comment] and !params[:comment].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: email must be an String") if params[:email] and !params[:email].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: platform_version must be an String") if params[:platform_version] and !params[:platform_version].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: release_channel must be an String") if params[:release_channel] and !params[:release_channel].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: build") unless params[:build]
+      raise MissingParameterError.new("Parameter missing: platform") unless params[:platform]
+      raise MissingParameterError.new("Parameter missing: product_name") unless params[:product_name]
+      raise MissingParameterError.new("Parameter missing: version") unless params[:version]
+
+      response, options = Api.send_request("/crash_reports", :post, params, options)
+      CrashReport.new(response.data, options)
+    end
+  end
+end

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

@@ -177,6 +177,15 @@ module Files
       CustomDomain.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 `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)
+
+      response, options = Api.send_request("/custom_domains/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   destination - string - Where this custom domain routes. Can be `site_alias`, `public_hosting`, or `s3_endpoint`.
     #   folder_behavior_id - int64 - Public Hosting behavior ID when this domain routes to a specific Public Hosting behavior.

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Files
+  class CustomDomainForProxy
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - Custom Domain ID.
+    def id
+      @attributes[:id]
+    end
+
+    # string - Customer-owned domain name.
+    def domain
+      @attributes[:domain]
+    end
+
+    # string - Routing destination: `site_alias`, `public_hosting`, or `s3_endpoint`.
+    def destination
+      @attributes[:destination]
+    end
+
+    # int64 - Attached SslCertificate ID.
+    def ssl_certificate_id
+      @attributes[:ssl_certificate_id]
+    end
+
+    # string - The text of the certificate itself.
+    def certificate
+      @attributes[:certificate]
+    end
+
+    # string - Private key used to generate the certificate.
+    def private_key
+      @attributes[:private_key]
+    end
+
+    # string - Intermediate certificates, if available.
+    def intermediates
+      @attributes[:intermediates]
+    end
+  end
+end

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

@@ -160,6 +160,17 @@ module Files
       DesktopConfigurationProfile.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 `workspace_id` and `name`.
+    #   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("/desktop_configuration_profiles/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   name - string - Profile name
     #   workspace_id - int64 - Workspace ID

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

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

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

@@ -83,5 +83,26 @@ 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 `created_at`, `sender`, `status` or `inbox_id`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `created_at`, `inbox_id`, `sender` or `status`. Valid field combinations are `[ inbox_id, created_at ]`, `[ sender, created_at ]`, `[ status, created_at ]`, `[ inbox_id, status ]`, `[ status, sender ]`, `[ inbox_id, status, created_at ]`, `[ status, sender, created_at ]`, `[ inbox_id, status, sender ]` or `[ inbox_id, status, sender, 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_prefix - object - If set, return records where the specified field is prefixed by the supplied value. Valid fields are `sender`.
+    #   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_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)
+
+      response, options = Api.send_request("/email_incoming_messages/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

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

@@ -59,6 +59,11 @@ module Files
       @attributes[:created_at]
     end
 
+    # string - Log Type
+    def log_type
+      @attributes[:log_type]
+    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: 2000, 1,000 or less is recommended).
@@ -84,5 +89,22 @@ module Files
     def self.all(params = {}, options = {})
       list(params, options)
     end
+
+    # Parameters:
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `status` and `created_at`. Valid field combinations are `[ status ]`, `[ created_at ]` or `[ status, created_at ]`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `created_at`. Valid field combinations are `[ status ]`, `[ created_at ]` or `[ status, 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`. Valid field combinations are `[ status ]`, `[ created_at ]` or `[ status, created_at ]`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `created_at`. Valid field combinations are `[ status ]`, `[ created_at ]` or `[ status, 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`. Valid field combinations are `[ status ]`, `[ created_at ]` or `[ status, created_at ]`.
+    def self.create_export(params = {}, options = {})
+      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("/email_logs/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Files
+  class EmailPreference
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # email - Email address
+    def email
+      @attributes[:email]
+    end
+
+    # array(object) - A list of notifications
+    def notifications
+      @attributes[:notifications]
+    end
+
+    # array(object) - A list of bundle notifications
+    def bundle_notifications
+      @attributes[:bundle_notifications]
+    end
+
+    # boolean - Deprecated. Use granular admin email preferences instead.
+    def receive_admin_alerts
+      @attributes[:receive_admin_alerts]
+    end
+
+    # boolean - Receive site warnings?
+    def notify_on_all_site_warnings
+      @attributes[:notify_on_all_site_warnings]
+    end
+
+    # boolean - Receive sso/scim/ldap configuration/sync failures?
+    def notify_on_all_sso_failures
+      @attributes[:notify_on_all_sso_failures]
+    end
+
+    # boolean - Receive user security events?
+    def notify_on_all_user_security_events
+      @attributes[:notify_on_all_user_security_events]
+    end
+
+    # boolean - Receive pending work failures?
+    def notify_on_all_pending_work_failures
+      @attributes[:notify_on_all_pending_work_failures]
+    end
+
+    # boolean - Receive siem failures?
+    def notify_on_all_siem_http_destination_failures
+      @attributes[:notify_on_all_siem_http_destination_failures]
+    end
+
+    # boolean - Receive sync failures?
+    def notify_on_all_sync_failures
+      @attributes[:notify_on_all_sync_failures]
+    end
+
+    # boolean - Receive automation failures?
+    def notify_on_all_automation_failures
+      @attributes[:notify_on_all_automation_failures]
+    end
+
+    # boolean - Receive expectation failures and misses?
+    def notify_on_all_expectation_failures
+      @attributes[:notify_on_all_expectation_failures]
+    end
+
+    # boolean - Receive marketing mail?
+    def receive_marketing_mail
+      @attributes[:receive_marketing_mail]
+    end
+
+    # boolean - Receive transactional (service-related) mail?
+    def receive_transactional_mail
+      @attributes[:receive_transactional_mail]
+    end
+
+    # Parameters:
+    #   token (required) - string - Email preferences token.
+    def self.get(token, params = {}, options = {})
+      params ||= {}
+      params[:token] = token
+      raise InvalidParameterError.new("Bad parameter: token must be an String") if params[:token] and !params[:token].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: token") unless params[:token]
+
+      response, options = Api.send_request("/email_preferences/#{params[:token]}", :get, params, options)
+      EmailPreference.new(response.data, options)
+    end
+
+    # Parameters:
+    #   token (required) - string - Email preferences token.
+    #   user[receive_admin_alerts] - boolean
+    #   user[notify_on_all_site_warnings] - boolean
+    #   user[notify_on_all_sso_failures] - boolean
+    #   user[notify_on_all_user_security_events] - boolean
+    #   user[notify_on_all_pending_work_failures] - boolean
+    #   user[notify_on_all_siem_http_destination_failures] - boolean
+    #   user[notify_on_all_sync_failures] - boolean
+    #   user[notify_on_all_automation_failures] - boolean
+    #   user[notify_on_all_expectation_failures] - boolean
+    #   user[unsubscribe_marketing] - boolean
+    #   user[unsubscribe_transactional] - boolean
+    #   user[unsubscribe] - boolean
+    #   user[notifications][id] (required) - array(int64)
+    #   user[notifications][group] - array(boolean)
+    #   user[notifications][send_interval] - array(string)
+    #   user[notifications][unsubscribe] - array(boolean)
+    #   user[bundle_notifications][id] (required) - array(int64)
+    #   user[bundle_notifications][unsubscribe] - array(boolean)
+    def self.update(token, params = {}, options = {})
+      params ||= {}
+      params[:token] = token
+      raise InvalidParameterError.new("Bad parameter: token must be an String") if params[:token] and !params[:token].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: token") unless params[:token]
+
+      response, options = Api.send_request("/email_preferences/#{params[:token]}", :patch, params, options)
+      EmailPreference.new(response.data, options)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Files
+  class EmailPreferenceBundleNotification
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - Email preferences ID
+    def id
+      @attributes[:id]
+    end
+
+    # string - Bundle code
+    def bundle_code
+      @attributes[:bundle_code]
+    end
+
+    # boolean - Is unsubscribed?
+    def unsubscribed
+      @attributes[:unsubscribed]
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Files
+  class EmailPreferenceNotification
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - Email preferences ID
+    def id
+      @attributes[:id]
+    end
+
+    # string - Folder path. This must be slash-delimited, but it must neither start nor end with a slash. Maximum of 5000 characters.
+    def path
+      @attributes[:path]
+    end
+
+    # string - The time interval that notifications are aggregated to.  Can be five_minutes, fifteen_minutes, hourly, or daily
+    def send_interval
+      @attributes[:send_interval]
+    end
+
+    # boolean - Is unsubscribed?
+    def unsubscribed
+      @attributes[:unsubscribed]
+    end
+  end
+end

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

@@ -170,6 +170,17 @@ module Files
       EventChannel.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 `name`, `enabled`, `default_channel` or `workspace_id`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `enabled`, `default_channel` or `workspace_id`. Valid field combinations are `[ workspace_id, enabled ]` and `[ workspace_id, default_channel ]`.
+    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("/event_channels/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   name - string - Event Channel name.
     #   workspace_id - int64 - Workspace ID. 0 means the default workspace.

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

@@ -119,5 +119,16 @@ 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`, `status`, `event_record_id`, `event_target_id` or `workspace_id`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `status`, `workspace_id`, `event_record_id` or `event_target_id`. Valid field combinations are `[ workspace_id, status ]`, `[ workspace_id, event_record_id ]` or `[ workspace_id, event_target_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("/event_delivery_attempts/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

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

@@ -129,5 +129,26 @@ 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 `event_type`, `created_at` or `workspace_id`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `created_at`, `event_type` or `workspace_id`. Valid field combinations are `[ event_type, created_at ]`, `[ workspace_id, created_at ]`, `[ workspace_id, event_type ]` or `[ workspace_id, event_type, 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_prefix - object - If set, return records where the specified field is prefixed by the supplied value. Valid fields are `event_type`.
+    #   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_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)
+
+      response, options = Api.send_request("/event_records/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end