files.com 1.1.786 → 1.1.787

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 297ac56fe0c1ad0e834dcd371599ce418443650c0c136adbd6530e42da051e09
-  data.tar.gz: 20c046024f6830e02e7b73daccbe7dbe32ec9cce8ca38509a8c932bc4b826ab3
+  metadata.gz: 3be6daf56fa9341e6485d6cb0bb2308fd12187b7192dec2d34e9027f215e8e50
+  data.tar.gz: ba1c8e66a7043f1beeded14ddbd3767168cb69cf5ea5a2ab1b46bbe961c7c9ee
 SHA512:
-  metadata.gz: a0ceefe70ae7603de8bdfcaa0856a40c08201ec2a601ec2a4003cb093c8cb0eab0ace565d4a704ce93e487cc1d57bce3b85363da27a80f426f74c0000918a118
-  data.tar.gz: 6e9c93ff74b7f96d603b1da2249373c57c4843fbfbc66508d46b62e55ff1880a1d80c33427247db753f633649adfdc7f66dc17fcac9894fa756d8707a354e78f
+  metadata.gz: 840ca503641785a0c6c699c0de6397718de6f2eda8297ae25f14f23a16a066df3c585566b85ab89a81049891a891825c79ceb8c324ec0f2eedcfa0bfc7074f25
+  data.tar.gz: d6c74d466ff98e3b8eb31f7d7bbb4b38a603fb67b0ec6c2eae183d55901d6dfd40870dfa32bf42f7b346fecc8847d9919144a4ce22c4f2893b32d8d91ddee7cb

data/README.md

@@ -305,7 +305,7 @@ end
 
 ```ruby title="Range Filter Example"
 begin
-  # users who haven't logged in since 2024-01-01
+  # users whose last login was on or after 2024-01-01
   Files::User.list(
     filter_gteq: { "last_login_at": "2024-01-01" }
   )
@@ -320,7 +320,7 @@ end
 begin
   # users whose usernames start with 'test'
   Files::User.list(
-    filter_pre: { username: "test" }
+    filter_prefix: { username: "test" }
   )
 rescue Files::NotAuthenticatedError => e
   puts "Authentication Error Occurred (#{e.class.to_s}): " + e.message

data/_VERSION

@@ -1 +1 @@
-1.1.786
+1.1.787

data/lib/files.com/api.rb

@@ -3,14 +3,21 @@
 module Files
   class Api
     # A given block receives the response and can reject it by raising. The
-    # caller's options take on the resolved client and credentials only after
-    # the request, and that check, succeed.
+    # returned options take on the resolved client and credentials, the
+    # regional origin a lockout region mismatch moved the request to, and the
+    # region_http_pairs the request used, only after the request, and that
+    # check, succeed; the caller's options are not changed. An options base_url
+    # sends the request there instead of to Files.base_url, and an options
+    # region_http_pairs is used instead of the client's.
     def self.send_request(path, verb, params, options)
       warn_on_options_in_params(params)
 
+      options = options.dup
       headers = options.clone
       api_key = headers.delete(:api_key)
+      base_url = headers.delete(:base_url)
       client = headers.delete(:client) || ApiClient.active_client
+      region_http_pairs = headers.delete(:region_http_pairs)
       session_id = headers.delete(:session_id)
       workspace_id = headers.delete(:workspace_id)
       if session = headers.delete(:session)
@@ -18,13 +25,21 @@ module Files
         session_id = session.id
       end
 
-      resp, api_key, session_id = client.execute_request(
-        verb, path, api_key: api_key, headers: headers, params: params, session_id: session_id, workspace_id: workspace_id
-      )
+      request_options = { api_key: api_key, headers: headers, params: params, session_id: session_id, workspace_id: workspace_id }
+      # Only an origin or pairs the request carries are passed on; without them the client uses its own as before.
+      request_options[:base_url] = base_url unless base_url.nil?
+      request_options[:region_http_pairs] = region_http_pairs unless region_http_pairs.nil?
+      regional_base_url = nil
+      resp, api_key, session_id = client.execute_request(verb, path, **request_options) do |origin, used_region_http_pairs|
+        regional_base_url = origin
+        region_http_pairs = used_region_http_pairs
+      end
       yield resp if block_given?
       options[:client] = client
       options[:api_key] = api_key
       options[:session_id] = session_id
+      options[:base_url] = regional_base_url if regional_base_url
+      options[:region_http_pairs] = region_http_pairs unless region_http_pairs.nil?
 
       # Hash#select returns an array before 1.9
       options_to_persist = {}

data/lib/files.com/api_client.rb

@@ -12,6 +12,11 @@ module Files
     USE_GLOBAL = Object.new.freeze
     private_constant :USE_GLOBAL
 
+    # Local and Files.com development domains. A lockout region mismatch moves a request to an https:// origin on one
+    # of these, or on a name under one, only with Files.region_handler's approval.
+    DEVELOPMENT_DOMAINS = %w[localhost local filesrails.test files.test].freeze
+    private_constant :DEVELOPMENT_DOMAINS
+
     # Creates a client that sends requests through +conn+, or through a new default connection when +conn+ is nil.
     #
     # By default the client logs its ordinary API requests, responses and errors through the library-wide Files.logger and
@@ -32,11 +37,18 @@ module Files
     # +workspace_id+ gives this client its own workspace; 0 is sent as "0". A request's own workspace_id option still
     # takes precedence, and a request whose workspace_id is nil uses this client's. Pass workspace_id: nil to name no
     # workspace for this client's requests even when Files.workspace_id is set.
-    def initialize(conn = nil, logger: USE_GLOBAL, log_level: USE_GLOBAL, workspace_id: USE_GLOBAL)
+    #
+    # A lockout region mismatch moves its requests over plain HTTP only from the source to the destination of a pair in
+    # the library-wide Files.region_http_pairs, read at the start of each request, unless +region_http_pairs+ gives this
+    # client its own pairs, in the same form. The client keeps a frozen copy of them, and [] allows none. A request's own
+    # region_http_pairs option, such as the one a returned record keeps, takes precedence over both. Plain HTTP is for
+    # your own development servers only (see Files.region_http_pairs=).
+    def initialize(conn = nil, logger: USE_GLOBAL, log_level: USE_GLOBAL, workspace_id: USE_GLOBAL, region_http_pairs: USE_GLOBAL)
       self.conn = conn || self.class.default_conn
       @logger = logger
       @log_level = log_level.equal?(USE_GLOBAL) ? log_level : Util.normalize_log_level(log_level)
       @workspace_id = workspace_id
+      @region_http_pairs = region_http_pairs.equal?(USE_GLOBAL) ? region_http_pairs : Util.checked_region_http_pairs(region_http_pairs)
       @system_profiler = SystemProfiler.new
       @last_request_metrics = nil
     end
@@ -96,8 +108,9 @@ module Files
       return false if num_retries >= Files.max_network_retries
       return true if error.is_a?(Faraday::TimeoutError)
       return true if error.is_a?(Faraday::ConnectionFailed)
-      return true if error.is_a?(Faraday::ServerError)
-      return true if error.is_a?(Faraday::ClientError) and error.response_status == 405
+      # 501 Not Implemented means the API does not support the request, so repeating it cannot succeed.
+      return true if error.is_a?(Faraday::ServerError) and error.response_status != 501
+      return true if error.is_a?(Faraday::ClientError) and [ 405, 429 ].include?(error.response_status)
 
       false
     end
@@ -124,7 +137,17 @@ module Files
       end
     end
 
-    def execute_request(method, path, base_url: nil, api_key: nil, session_id: nil, workspace_id: nil, headers: {}, params: {})
+    # The frozen [source, destination] pairs of http:// origins this client's requests use when they name none of their
+    # own: the client's own, or Files.region_http_pairs.
+    def region_http_pairs
+      @region_http_pairs.equal?(USE_GLOBAL) ? Files.region_http_pairs : @region_http_pairs
+    end
+
+    # Returns the response and the API key and session ID the request used. +region_http_pairs+, such as the pairs a
+    # returned record keeps, is used instead of this client's. The block, if given, receives the request's context once
+    # its response has arrived: the regional origin a lockout region mismatch moved it to, or nil, and the frozen
+    # region_http_pairs it used.
+    def execute_request(method, path, base_url: nil, api_key: nil, session_id: nil, workspace_id: nil, region_http_pairs: nil, headers: {}, params: {}, &on_request_context)
       base_url ||= Files.base_url
       if api_key.nil?
         session_id ||= Files.session_id
@@ -155,12 +178,22 @@ module Files
       context = RequestLogContext.new
       context.api_key      = api_key
       context.body         = body
+      context.headers      = headers
       context.method       = method
       context.path         = path
       context.query_params = query_params if query_params
       context.session_id   = session_id
 
-      http_resp = execute_request_with_rescues(base_url, context) do
+      regional_base_url = nil
+      # Fixed before the request starts, so later changes to the caller's or the library-wide pairs cannot affect it.
+      http_pairs = region_http_pairs.nil? ? self.region_http_pairs : Util.checked_region_http_pairs(region_http_pairs)
+      relocate = lambda do |error_response|
+        regional_base_url = region_continuation_base_url(error_response, base_url, body, http_pairs)
+        url = api_url(path, regional_base_url) if regional_base_url
+        regional_base_url
+      end
+
+      http_resp = execute_request_with_rescues(base_url, context, relocate: relocate) do
         conn.run_request(method, url, body, headers) do |req|
           req.options.open_timeout = Files.open_timeout
           req.options.timeout = Files.read_timeout
@@ -175,6 +208,7 @@ module Files
       end
 
       @last_response = resp
+      on_request_context&.call(regional_base_url, http_pairs)
       [ resp, api_key, session_id ]
     end
 
@@ -287,15 +321,143 @@ module Files
     end
 
     private def api_url(url = "", base_url = nil)
+      begin
+        root = Addressable::URI.parse(base_url)
+      rescue Addressable::URI::InvalidURIError
+        # The parser's message can include the whole URL and its credentials, so only the cause carries it.
+        raise InvalidParameterError, "Invalid Files.com base URL. Use an http:// or https:// URL with a valid host and port, such as https://app.files.com."
+      end
+
+      # Other schemes fail inside Net::HTTP with a NoMethodError rather than a Files::Error.
+      raise InvalidParameterError, "Unsupported Files.com base URL scheme \"#{root.scheme}\". Use an http:// or https:// base URL, such as https://app.files.com." unless root.scheme.nil? || %w[http https].include?(root.scheme.downcase)
+
       uri        = Addressable::URI.new
-      uri.host   = Addressable::URI.parse(base_url).host
-      uri.port   = Addressable::URI.parse(base_url).port
+      uri.host   = root.host
+      uri.port   = root.port
       uri.path   = "/api/rest/v1#{Files::URI.normalized_path(url)}"
-      uri.scheme = Addressable::URI.parse(base_url).scheme
+      uri.scheme = root.scheme
 
       uri.to_s
     end
 
+    # The origin a lockout region mismatch moves this request to, or nil to raise the error as it is. The API answers
+    # with that error, naming the site's own origin in data.host, when the site is pinned to another region or to a
+    # custom domain. Only the configured HTTPS origin, reached over this client's verified connection, may send the
+    # credentials elsewhere, apart from an http:// origin to the destination +http_pairs+ pairs it with.
+    private def region_continuation_base_url(error_response, base_url, body, http_pairs)
+      return if Files.region_policy == :disabled
+
+      error_object = error_response.data
+      return unless error_response.http_status == 403 && error_object[:type] == "not-authenticated/lockout-region-mismatch"
+      return unless replayable?(body)
+
+      host = error_object[:data].is_a?(Hash) ? error_object[:data][:host] : nil
+      return http_pair_origin(base_url, host, http_pairs) unless verified_https_connection?(base_url)
+
+      configured = Addressable::URI.parse(base_url)
+      original_origin = https_origin(configured.normalized_host, configured.inferred_port)
+      target_origin, approval_required = region_target(host)
+      # A mismatch that names the origin it came from cannot be resolved by moving, so the handler is not asked.
+      return if target_origin.nil? || target_origin == original_origin
+
+      if Files.region_handler
+        target_origin = approved_region_origin(original_origin, target_origin, approval_required) { |decision| region_target(decision)&.first }
+      elsif approval_required
+        return
+      end
+      return if target_origin.nil? || target_origin == original_origin
+
+      Util.log_info("Region continuation", { from: original_origin, to: target_origin }, log_settings)
+      target_origin
+    end
+
+    # The origin Files.region_handler approves: the target for true, or another origin it returns that the block gives
+    # back unchanged, as the canonical form of an origin the request may move to. nil when it declines. The handler
+    # gets frozen copies, so it cannot change the origins used here.
+    private def approved_region_origin(original_origin, target_origin, approval_required)
+      event = { reason: :lockout_region_mismatch, original_origin: original_origin.dup.freeze, target_origin: target_origin.dup.freeze, approval_required: approval_required }.freeze
+      decision = Files.region_handler.call(event)
+      return target_origin if decision == true
+      return unless decision.is_a?(String)
+
+      approved_origin = yield(decision)
+      approved_origin if approved_origin == decision
+    end
+
+    # The http:// origin data.host names when +http_pairs+ pairs it with +base_url+'s own http:// origin, or nil. Plain
+    # HTTP proves nothing about who answered, so only that exact pair, the caller's own choice, gives the authority to
+    # continue. Within it a bare host means that host over plain HTTP, on port 80 unless it names another port. The
+    # region handler may still decline, or choose another destination paired with the same source; the request then
+    # continues at that pair's own frozen destination, not at the String the handler returned.
+    private def http_pair_origin(base_url, host, http_pairs)
+      original_origin = Util.http_origin(base_url)
+      target_origin = Util.http_origin(host.is_a?(String) && !host.include?("://") ? "http://#{host}" : host)
+      return unless original_origin && target_origin != original_origin && http_pairs.include?([ original_origin, target_origin ])
+
+      if Files.region_handler
+        target_origin = approved_region_origin(original_origin, target_origin, false) do |decision|
+          http_pairs.find { |source, destination| source == original_origin && destination == decision }&.last
+        end
+      end
+      return if target_origin.nil? || target_origin == original_origin
+
+      Util.log_info("Region continuation", { from: original_origin, to: target_origin }, log_settings)
+      target_origin
+    end
+
+    # Whether a response through this client came from +base_url+ over verified HTTPS: the SDK's own middleware and a
+    # Net::HTTP adapter, with certificate and host name verification on. Other middleware or adapters, such as a
+    # caller's, could produce a response that never came from there.
+    private def verified_https_connection?(base_url)
+      return false unless Addressable::URI.parse(base_url).scheme.to_s.casecmp?("https") && conn.is_a?(Faraday::Connection)
+
+      ssl = conn.ssl
+      ssl.verify? && ssl.verify_hostname? && [ nil, OpenSSL::SSL::VERIFY_PEER ].include?(ssl.verify_mode) &&
+      conn.builder.handlers == self.class.build_default_conn.builder.handlers &&
+      [ Faraday::Adapter::NetHttp, Faraday::Adapter::NetHttpPersistent ].include?(conn.builder.adapter&.klass)
+    end
+
+    # Whether +body+ can be sent again. A file in a multipart body has already been read.
+    private def replayable?(body)
+      case body
+      when Hash then body.values.all? { |value| replayable?(value) }
+      when Array then body.all? { |value| replayable?(value) }
+      else !body.respond_to?(:read)
+      end
+    end
+
+    # The HTTPS origin data.host names and whether continuing there needs the region handler's approval, or nil when
+    # data.host is not a plain origin. It may be a host name, with or without a port, or an https:// origin whose path
+    # is empty or "/"; credentials, a query, a fragment, a path, another scheme, spaces or backslashes are refused.
+    # Without approval the request continues only to a DNS name on port 443: an IP address, a local or Files.com
+    # development name (DEVELOPMENT_DOMAINS, or a name without a dot) or another port needs the handler to allow it.
+    private def region_target(host)
+      return unless host.is_a?(String) && !host.match?(/[[:space:][:cntrl:]\\]/)
+
+      origin = host.include?("://") ? host : "https://#{host}"
+      return unless origin.match?(/\Ahttps:\/\/[^\/?#@]+\/?\z/i)
+
+      uri = Addressable::URI.parse(origin)
+      name = uri.normalized_host.to_s
+      port = uri.port || 443
+      ip_address = name.match?(/\A\[[0-9a-f:.]+\]\z/) || name.match?(/\A\d{1,3}(\.\d{1,3}){3}\z/)
+      return unless port.between?(1, 65_535) && (ip_address || dns_name?(name))
+
+      local = ip_address || !name.include?(".") || DEVELOPMENT_DOMAINS.any? { |domain| name == domain || name.end_with?(".#{domain}") }
+      [ https_origin(name, port), local || port != 443 ]
+    rescue Addressable::URI::InvalidURIError, ArgumentError
+      nil
+    end
+
+    private def dns_name?(name)
+      labels = name.split(".", -1)
+      name.length <= 253 && labels.all? { |label| label.match?(/\A[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\z/) } && !labels.last.match?(/\A\d+\z/)
+    end
+
+    private def https_origin(host, port)
+      port == 443 ? "https://#{host}" : "https://#{host}:#{port}"
+    end
+
     private def check_api_key!(api_key)
       raise AuthenticationError, "No Files.com API key provided. Set your API key using \"Files.api_key = <API-KEY>\". You can generate API keys from the Files.com's web interface. " unless api_key
       raise AuthenticationError, "Your API key must be a string" unless api_key.is_a?(String)
@@ -311,20 +473,23 @@ module Files
       raise AuthenticationError, "The provided Session ID is invalid (it contains whitespace)"
     end
 
-    def execute_request_with_rescues(base_url, context, skip_body_logging: false, is_transfer: false)
+    # +relocate+, given only for ordinary API requests, receives a structured error response and returns the regional
+    # origin to send the request to instead, or nil. The request is sent there at most once, and retries before and
+    # after count together.
+    def execute_request_with_rescues(base_url, context, skip_body_logging: false, is_transfer: false, relocate: nil)
       num_retries = 0
       begin
         request_start = Time.now
         log_request(context, num_retries, no_body: skip_body_logging)
         resp = yield
-        log_response(context, request_start, resp.status, resp.body, no_body: skip_body_logging)
+        log_response(context, request_start, resp.status, resp.body, headers: resp.headers, no_body: skip_body_logging)
       rescue StandardError => e
         error_context = context
 
         if e.respond_to?(:response) && e.response
           error_context = context
           log_response(error_context, request_start,
-                       e.response[:status], e.response[:body], no_body: skip_body_logging
+                       e.response[:status], e.response[:body], headers: e.response[:headers], no_body: skip_body_logging
           )
         else
           log_response_error(error_context, request_start, e)
@@ -332,7 +497,9 @@ module Files
 
         if self.class.should_retry?(e, num_retries)
           num_retries += 1
-          sleep self.class.sleep_time(num_retries)
+          wait_seconds = self.class.sleep_time(num_retries)
+          log_retry(context, num_retries, e, wait_seconds) unless is_transfer
+          sleep wait_seconds
           retry
         end
 
@@ -340,7 +507,14 @@ module Files
 
         case e
         when Faraday::ClientError, Faraday::ServerError
-          if (error_response = api_error_response(e.response))
+          error_response = api_error_response(e.response)
+          if relocate && error_response && (regional_base_url = relocate.call(error_response))
+            relocate = nil
+            base_url = regional_base_url
+            retry
+          end
+
+          if error_response
             handle_error_response(error_response, error_context, is_transfer: is_transfer)
           else
             handle_network_error(e, error_context, num_retries, base_url, is_transfer: is_transfer)
@@ -348,6 +522,7 @@ module Files
         else
           raise e.exception("Transfer request failed (#{e.class})"), cause: nil if is_transfer
 
+          handle_network_error(e, error_context, num_retries, base_url) if e.is_a?(Faraday::ConnectionFailed) || e.is_a?(Faraday::SSLError)
           raise
         end
       end
@@ -536,12 +711,12 @@ module Files
 
     private def log_request(context, num_retries, no_body: false)
       Util.log_info("Request", { method: context.method, num_retries: num_retries, path: context.path }, log_settings)
-      Util.log_debug("Request details", { body: context.body, query_params: context.query_params }, log_settings) unless no_body
+      Util.log_debug("Request details", { body: context.body, headers: context.headers, query_params: context.query_params }, log_settings) unless no_body
     end
 
-    private def log_response(context, request_start, status, body, no_body: false)
+    private def log_response(context, request_start, status, body, headers: nil, no_body: false)
       Util.log_info("Response", { elapsed: Time.now - request_start, method: context.method, path: context.path, status: status }, log_settings)
-      Util.log_debug("Response details", { body: body }, log_settings) unless no_body
+      Util.log_debug("Response details", { body: body, headers: headers }, log_settings) unless no_body
     end
 
     private def log_response_error(context, request_start, error)
@@ -549,6 +724,10 @@ module Files
       Util.log_debug("Error details", { error_message: error.message }, log_settings)
     end
 
+    private def log_retry(context, attempt, error, wait_seconds)
+      Util.log_info("Retry", { attempt: attempt, error_type: error.class, max_retries: Files.max_network_retries, method: context.method, path: context.path, status: error.response_status, wait_seconds: wait_seconds }, log_settings)
+    end
+
     # This client's own logger and level where it set them, and the library-wide ones otherwise.
     private def log_settings
       Util::LogSettings.new(@logger.equal?(USE_GLOBAL) ? Files.logger : @logger,
@@ -562,7 +741,7 @@ module Files
     end
 
     class RequestLogContext
-      attr_accessor :body, :api_key, :method, :path, :query_params, :session_id
+      attr_accessor :body, :api_key, :headers, :method, :path, :query_params, :session_id
     end
   end
 end

data/lib/files.com/list.rb

@@ -118,8 +118,10 @@ module Files
     def request_page(cursor)
       response, options = @request.call(cursor ? @params.merge(cursor: cursor) : @params) { |reply| reply.require_list(@resource_wrapper) }
       records = response.data.map { |attributes| @resource_wrapper.new(attributes, options) }
-      next_cursor = response.http_headers["x-files-cursor"]
-      Page.new(records, cursor, (next_cursor unless next_cursor.to_s.strip.empty?))
+      # The API documents X-Files-Cursor-Next for the next page's cursor; X-Files-Cursor is the older header. A blank
+      # cursor means there is no next page.
+      next_cursor = %w[x-files-cursor-next x-files-cursor].map { |name| response.http_headers[name] }.find { |value| !value.to_s.strip.empty? }
+      Page.new(records, cursor, next_cursor)
     end
 
     def with_page(page)

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

@@ -105,8 +105,11 @@ module Files
       raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if !params[:filter_lt].nil? and !params[:filter_lt].is_a?(Hash)
       raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if !params[:filter_lteq].nil? and !params[:filter_lteq].is_a?(Hash)
 
+      list_options = options.dup
       List.new(ActionLog, params) do |page_params, &check_page|
-        Api.send_request("/action_logs", :get, page_params, options, &check_page)
+        response, page_options = Api.send_request("/action_logs", :get, page_params, list_options, &check_page)
+        list_options = list_options.merge(page_options)
+        [ response, page_options ]
       end
     end
 

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

@@ -152,6 +152,7 @@ module Files
       else
         new_obj = ActionNotificationExport.create(@attributes, @options)
         @attributes = new_obj.attributes
+        @options = @options.merge(new_obj.options)
       end
 
       true
@@ -165,7 +166,7 @@ module Files
     #
     # Returns a Files::ActionNotificationExport.
     def self.find(id, params = {}, options = {})
-      params ||= {}
+      params = (params || {}).dup
       params[:id] = id
       raise InvalidParameterError.new("Bad parameter: id must be an Integer") if !params[:id].nil? and !params[:id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: id") if params[:id].nil?
@@ -204,6 +205,7 @@ module Files
       raise InvalidParameterError.new("Bad parameter: query_request_method must be an String") if !params[:query_request_method].nil? and !params[:query_request_method].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: query_request_url must be an String") if !params[:query_request_url].nil? and !params[:query_request_url].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: query_status must be an String") if !params[:query_status].nil? and !params[:query_status].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: query_success must be a single value, not #{params[:query_success].class}") if [ Array, Hash ].any? { |klass| params[:query_success].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: query_path must be an String") if !params[:query_path].nil? and !params[:query_path].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: query_folder must be an String") if !params[:query_folder].nil? and !params[:query_folder].is_a?(String)
 

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

@@ -78,8 +78,11 @@ module Files
       raise InvalidParameterError.new("Bad parameter: action_notification_export_id must be an Integer") if !params[:action_notification_export_id].nil? and !params[:action_notification_export_id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: action_notification_export_id") if params[:action_notification_export_id].nil?
 
+      list_options = options.dup
       List.new(ActionNotificationExportResult, params) do |page_params, &check_page|
-        Api.send_request("/action_notification_export_results", :get, page_params, options, &check_page)
+        response, page_options = Api.send_request("/action_notification_export_results", :get, page_params, list_options, &check_page)
+        list_options = list_options.merge(page_options)
+        [ response, page_options ]
       end
     end
 

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

@@ -82,29 +82,34 @@ module Files
     #   use_by_default - boolean - Whether this personality is the default personality for the Workspace.
     #   workspace_id - int64 - Workspace ID. `0` means the default workspace.
     def update(params = {})
-      params ||= {}
+      params = (params || {}).dup
       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].nil? and !params[:id].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: apply_to_all_workspaces must be a single value, not #{params[:apply_to_all_workspaces].class}") if [ Array, Hash ].any? { |klass| params[:apply_to_all_workspaces].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: name must be an String") if !params[:name].nil? and !params[:name].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: system_prompt must be an String") if !params[:system_prompt].nil? and !params[:system_prompt].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: use_by_default must be a single value, not #{params[:use_by_default].class}") if [ Array, Hash ].any? { |klass| params[:use_by_default].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: workspace_id must be an Integer") if !params[:workspace_id].nil? and !params[:workspace_id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: id") if params[:id].nil?
 
       response, options = Api.send_request("/ai_assistant_personalities/#{@attributes[:id]}", :patch, params, @options) { |reply| reply.require_object("AiAssistantPersonality") }
       @attributes = response.data
+      @options = @options.merge(options)
       [ response, options ]
     end
 
     # Returns the [response, options] pair from Files::Api.send_request.
     def delete(params = {})
-      params ||= {}
+      params = (params || {}).dup
       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].nil? and !params[:id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: id") if params[:id].nil?
 
-      Api.send_request("/ai_assistant_personalities/#{@attributes[:id]}", :delete, params, @options)
+      response, options = Api.send_request("/ai_assistant_personalities/#{@attributes[:id]}", :delete, params, @options)
+      @options = @options.merge(options)
+      [ response, options ]
     end
 
     # Alias for #delete. Returns nil.
@@ -119,6 +124,7 @@ module Files
       else
         new_obj = AiAssistantPersonality.create(@attributes, @options)
         @attributes = new_obj.attributes
+        @options = @options.merge(new_obj.options)
       end
 
       true
@@ -140,8 +146,11 @@ module Files
       raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if !params[:sort_by].nil? and !params[:sort_by].is_a?(Hash)
       raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if !params[:filter].nil? and !params[:filter].is_a?(Hash)
 
+      list_options = options.dup
       List.new(AiAssistantPersonality, params) do |page_params, &check_page|
-        Api.send_request("/ai_assistant_personalities", :get, page_params, options, &check_page)
+        response, page_options = Api.send_request("/ai_assistant_personalities", :get, page_params, list_options, &check_page)
+        list_options = list_options.merge(page_options)
+        [ response, page_options ]
       end
     end
 
@@ -157,7 +166,7 @@ module Files
     #
     # Returns a Files::AiAssistantPersonality.
     def self.find(id, params = {}, options = {})
-      params ||= {}
+      params = (params || {}).dup
       params[:id] = id
       raise InvalidParameterError.new("Bad parameter: id must be an Integer") if !params[:id].nil? and !params[:id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: id") if params[:id].nil?
@@ -182,8 +191,10 @@ module Files
     #
     # Returns a Files::AiAssistantPersonality.
     def self.create(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: apply_to_all_workspaces must be a single value, not #{params[:apply_to_all_workspaces].class}") if [ Array, Hash ].any? { |klass| params[:apply_to_all_workspaces].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: name must be an String") if !params[:name].nil? and !params[:name].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: system_prompt must be an String") if !params[:system_prompt].nil? and !params[:system_prompt].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: use_by_default must be a single value, not #{params[:use_by_default].class}") if [ Array, Hash ].any? { |klass| params[:use_by_default].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: workspace_id must be an Integer") if !params[:workspace_id].nil? and !params[:workspace_id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: name") if params[:name].nil?
       raise MissingParameterError.new("Parameter missing: system_prompt") if params[:system_prompt].nil?
@@ -204,11 +215,13 @@ module Files
     #
     # Returns a Files::AiAssistantPersonality.
     def self.update(id, params = {}, options = {})
-      params ||= {}
+      params = (params || {}).dup
       params[:id] = id
       raise InvalidParameterError.new("Bad parameter: id must be an Integer") if !params[:id].nil? and !params[:id].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: apply_to_all_workspaces must be a single value, not #{params[:apply_to_all_workspaces].class}") if [ Array, Hash ].any? { |klass| params[:apply_to_all_workspaces].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: name must be an String") if !params[:name].nil? and !params[:name].is_a?(String)
       raise InvalidParameterError.new("Bad parameter: system_prompt must be an String") if !params[:system_prompt].nil? and !params[:system_prompt].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: use_by_default must be a single value, not #{params[:use_by_default].class}") if [ Array, Hash ].any? { |klass| params[:use_by_default].is_a?(klass) }
       raise InvalidParameterError.new("Bad parameter: workspace_id must be an Integer") if !params[:workspace_id].nil? and !params[:workspace_id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: id") if params[:id].nil?
 
@@ -221,7 +234,7 @@ module Files
     #
     # Returns nil.
     def self.delete(id, params = {}, options = {})
-      params ||= {}
+      params = (params || {}).dup
       params[:id] = id
       raise InvalidParameterError.new("Bad parameter: id must be an Integer") if !params[:id].nil? and !params[:id].is_a?(Integer)
       raise MissingParameterError.new("Parameter missing: id") if params[:id].nil?