intercom 3.5.10 → 3.9.5

data/RELEASING.md

@@ -0,0 +1,9 @@
+# Releasing Intercom
+
+We use https://github.com/svenfuchs/gem-release to tag, bump, and release new versions
+
+Please add a line to changes.txt before you release a new version.
+
+```
+gem bump --tag --release
+```

data/changes.txt

@@ -1,3 +1,119 @@
+3.9.4
+Add handling for Gateway Timeouts
+
+3.9.3
+Fix regression added in 3.9.2
+
+3.9.2
+Added error handling for malformed responses
+
+3.9.1
+Version skipped in error
+
+3.9.0
+Added Teams endpoint functionality
+
+3.8.1
+Added error handling for company_not_found
+
+3.8.0
+Add support for Customer Search (currently in Unstable API Version)
+https://developers.intercom.com/intercom-api-reference/v0/reference#customers
+
+3.7.7
+Remove deprecated features from Gemspec
+
+3.7.6
+Added error handling for invalid_document error state
+
+3.7.5
+Added error handling for scroll_exists error state
+
+3.7.4
+Added support for API versioning via
+Intercom::Client.new(token: "token", api_version "1.1")
+
+3.7.3
+Added error handling for when an admin cannot be found.
+
+3.7.2
+Added error handling for when an app's custom attribute limits have been reached.
+
+3.7.1
+Extra version bump after faulty previous bump
+
+3.7.0
+Providing the ability to hard delete users as described here:
+https://developers.intercom.com/intercom-api-reference/reference#archive-a-user
+
+This chaged the previous delete action to an archive action and added a new hard delete option
+You can still use the delete method but it will archive a user, we added an alias for delete.
+#442 archiving alias
+#410 add ability to hard delete users
+
+Alos enabling reply to last from the SDK
+#443 Residently conversations last reply
+
+3.6.2
+#384 Add ability to snooze conversation
+You can now snooze conversations in your app via:
+intercom.conversations.snooze(...)
+
+3.6.1
+#430 Allow all conversations to be listed
+You can now iterate over all conversations for your app via:
+intercom.conversations.all.each { |convo| ... }
+
+3.6.0
+BREAKING CHANGE companies
+We updated companies to be able to list users via company_id as well as id (#428 )
+Note that this is a breaking change as we had to remove the old way of listing users via company.
+
+Previously it was:
+intercom.companies.users(company.id)
+
+Now you get a list of users in a company by Intercom Company ID
+intercom.companies.users_by_intercom_company_id(company.id)
+
+Now you get a list of users in a company by external company_id
+intercom.companies.users_by_company_id(company.company_id)
+
+Rate limit handling
+We also improved the way we handle rate limits in PR #409 which was related to issue #405
+
+3.5.23
+ - New type of error (ResourceNotUniqueError). Thrown when trying to create a resource that already exists in Intercom
+
+3.5.22
+ - Return object type
+
+3.5.21
+ - Fix for PR-353 which addressed "NoMethodError in intercom/request"
+ - There were issues on older versions of Ruby (<2.3)
+ - This PR does not use lonely operator and instead simple checks for nil parsed_body
+
+3.5.17
+ - Fix BlockedUserError typo
+
+3.5.16
+ - Standardize comparison of attribute as string when input is Hash or JSON
+
+3.5.15
+- UnauthorizedError on invalid token
+- BlockerUserError on restoring blocked user
+
+3.5.14
+- Rate Limit Exception (@jaimeiniesta)
+
+3.5.12
+- Use base_url in initialize parameter
+
+3.5.11
+- Add scroll api for companies
+
+3.5.10
+  - Add Support for find_all events pagination (@jkeyes)
+
 3.5.9
  - Fix event create method
 

data/intercom.gemspec

@@ -12,7 +12,6 @@ Gem::Specification.new do |spec|
   spec.summary     = %q{Ruby bindings for the Intercom API}
   spec.description = %Q{Intercom (https://www.intercom.io) is a customer relationship management and messaging tool for web app owners. This library wraps the api provided by Intercom. See http://docs.intercom.io/api for more details. }
   spec.license     = "MIT"
-  spec.rubyforge_project = "intercom"
 
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -20,12 +19,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency 'minitest', '~> 5.4'
+  spec.add_development_dependency "m", "~> 1.5.0"
   spec.add_development_dependency 'rake', '~> 10.3'
   spec.add_development_dependency 'mocha', '~> 1.0'
   spec.add_development_dependency "fakeweb", ["~> 1.3"]
   spec.add_development_dependency "pry"
 
-  spec.add_dependency 'json', '>= 1.8'
   spec.required_ruby_version = '>= 2.1.0'
   spec.add_development_dependency 'gem-release'
 end

data/lib/intercom.rb

@@ -4,6 +4,7 @@ require 'intercom/service/company'
 require 'intercom/service/contact'
 require 'intercom/service/conversation'
 require 'intercom/service/count'
+require 'intercom/service/customer'
 require 'intercom/service/event'
 require 'intercom/service/message'
 require 'intercom/service/note'
@@ -11,12 +12,14 @@ require 'intercom/service/job'
 require 'intercom/service/subscription'
 require 'intercom/service/segment'
 require 'intercom/service/tag'
+require 'intercom/service/team'
 require 'intercom/service/user'
 require 'intercom/service/visitor'
 require 'intercom/options'
 require 'intercom/client'
 require "intercom/contact"
 require "intercom/count"
+require "intercom/customer"
 require "intercom/user"
 require "intercom/company"
 require "intercom/note"
@@ -29,6 +32,7 @@ require "intercom/message"
 require "intercom/admin"
 require "intercom/request"
 require "intercom/subscription"
+require "intercom/team"
 require "intercom/errors"
 require "intercom/visitor"
 require "json"

data/lib/intercom/api_operations/{delete.rb → archive.rb}

@@ -2,12 +2,14 @@ require 'intercom/utils'
 
 module Intercom
   module ApiOperations
-    module Delete
-      def delete(object)
+    module Archive
+      def archive(object)
         collection_name = Utils.resource_class_to_collection_name(collection_class)
         @client.delete("/#{collection_name}/#{object.id}", {})
         object
       end
+
+      alias_method 'delete', 'archive'
     end
   end
 end

data/lib/intercom/api_operations/find_all.rb

@@ -16,7 +16,7 @@ module Intercom
           finder_details[:url] = "/#{collection_name}"
           finder_details[:params] = params
         end
-        ClientCollectionProxy.new(collection_name, finder_details: finder_details,  client: @client)
+        collection_proxy_class.new(collection_name, finder_details: finder_details,  client: @client)
       end
 
       private

data/lib/intercom/api_operations/request_hard_delete.rb

@@ -0,0 +1,12 @@
+require 'intercom/utils'
+
+module Intercom
+  module ApiOperations
+    module RequestHardDelete
+      def request_hard_delete(object)
+        @client.post("/user_delete_requests", {intercom_user_id: object.id})
+        object
+      end
+    end
+  end
+end

data/lib/intercom/api_operations/search.rb

@@ -0,0 +1,17 @@
+require 'intercom/search_collection_proxy'
+require 'intercom/utils'
+
+module Intercom
+  module ApiOperations
+    module Search
+      def search(params)
+        collection_name = Utils.resource_class_to_collection_name(collection_class)
+        search_details = {
+          url: "/#{collection_name}/search",
+          params: params
+        }
+        SearchCollectionProxy.new(collection_name, search_details: search_details, client: @client)
+      end
+    end
+  end
+end

data/lib/intercom/client.rb

@@ -2,7 +2,7 @@ module Intercom
   class MisconfiguredClientError < StandardError; end
   class Client
     include Options
-    attr_reader :base_url, :rate_limit_details, :username_part, :password_part
+    attr_reader :base_url, :rate_limit_details, :username_part, :password_part, :handle_rate_limit, :timeouts, :api_version
 
     class << self
       def set_base_url(base_url)
@@ -12,9 +12,20 @@ module Intercom
           Proc.new { |obj| set_base_url(old_url).call(o) }
         end
       end
+
+      def set_timeouts(open_timeout: nil, read_timeout: nil)
+        return Proc.new do |o|
+          old_timeouts = o.timeouts
+          timeouts = {}
+          timeouts[:open_timeout] = open_timeout if open_timeout
+          timeouts[:read_timeout] = read_timeout if read_timeout
+          o.send(:timeouts=, timeouts)
+          Proc.new { |obj| set_timeouts(old_timeouts).call(o) }
+        end
+      end
     end
 
-    def initialize(app_id: 'my_app_id', api_key: 'my_api_key', token: nil)
+    def initialize(app_id: 'my_app_id', api_key: 'my_api_key', token: nil, base_url:'https://api.intercom.io', handle_rate_limit: false, api_version: nil)
       if token
         @username_part = token
         @password_part = ""
@@ -24,8 +35,16 @@ module Intercom
       end
       validate_credentials!
 
-      @base_url = 'https://api.intercom.io'
+      @api_version = api_version
+      validate_api_version!
+
+      @base_url = base_url
       @rate_limit_details = {}
+      @handle_rate_limit = handle_rate_limit
+      @timeouts = {
+        open_timeout: 30,
+        read_timeout: 90
+      }
     end
 
     def admins
@@ -48,6 +67,10 @@ module Intercom
       Intercom::Service::Counts.new(self)
     end
 
+    def customers
+      Intercom::Service::Customer.new(self)
+    end
+
     def events
       Intercom::Service::Event.new(self)
     end
@@ -72,6 +95,10 @@ module Intercom
       Intercom::Service::Tag.new(self)
     end
 
+    def teams
+      Intercom::Service::Team.new(self)
+    end
+
     def users
       Intercom::Service::User.new(self)
     end
@@ -107,14 +134,24 @@ module Intercom
       fail error if @username_part.nil?
     end
 
+    def validate_api_version!
+      error = MisconfiguredClientError.new("api_version must be either nil or a valid API version")
+      fail error if (@api_version && @api_version != 'Unstable' && Gem::Version.new(@api_version) < Gem::Version.new('1.0'))
+    end
+
     def execute_request(request)
-      result = request.execute(@base_url, username: @username_part, secret: @password_part)
+      request.handle_rate_limit = handle_rate_limit
+      request.execute(@base_url, username: @username_part, secret: @password_part, api_version: @api_version, **timeouts)
+    ensure
       @rate_limit_details = request.rate_limit_details
-      result
     end
 
     def base_url=(new_url)
       @base_url = new_url
     end
+
+    def timeouts=(timeouts)
+      @timeouts = @timeouts.merge(timeouts)
+    end
   end
 end

data/lib/intercom/customer.rb

@@ -0,0 +1,10 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Customer
+    include Traits::ApiResource
+
+    def identity_vars ; [:id, :email, :user_id] ; end
+    def flat_store_attributes ; [:custom_attributes] ; end
+  end
+end

data/lib/intercom/errors.rb

@@ -23,16 +23,28 @@ module Intercom
     end
   end
 
-  # Raised when the credentials you provide don't match a valid account on Intercom.
-  # Check that you have set <b>Intercom.app_id=</b> and <b>Intercom.app_api_key=</b> correctly.
+  # Raised when the token you provided is incorrect or not authorized to access certain type of data.
+  # Check that you have set Intercom.token correctly.
   class AuthenticationError < IntercomError; end
 
+  # Raised when the token provided is linked to a deleted application.
+  class AppSuspendedError < AuthenticationError; end
+
+  # Raised when the token provided has been revoked.
+  class TokenRevokedError < AuthenticationError; end
+
+  # Raised when the token provided can't be decoded, and is most likely invalid.
+  class TokenUnauthorizedError < AuthenticationError; end
+
   # Raised when something goes wrong on within the Intercom API service.
   class ServerError < IntercomError; end
 
   # Raised when we have bad gateway errors.
   class BadGatewayError < IntercomError; end
 
+  # Raised when we have gateway timeout errors.
+  class GatewayTimeoutError < IntercomError; end
+
   # Raised when we experience a socket read timeout
   class ServiceUnavailableError < IntercomError; end
 
@@ -42,23 +54,47 @@ module Intercom
   # Raised when requesting resources on behalf of a user that doesn't exist in your application on Intercom.
   class ResourceNotFound < IntercomError; end
 
+  # Raised when requesting an admin that doesn't exist in your Intercom workspace.
+  class AdminNotFound < IntercomError; end
+
+  # Raised when trying to create a resource that already exists in Intercom.
+  class ResourceNotUniqueError < IntercomError; end
+
   # Raised when the request has bad syntax
   class BadRequestError < IntercomError; end
 
   # Raised when you have exceeded the API rate limit
   class RateLimitExceeded < IntercomError; end
 
+  # Raised when some attribute of the response cannot be handled
+  class UnexpectedResponseError < IntercomError; end
+
   # Raised when the request throws an error not accounted for
   class UnexpectedError < IntercomError; end
 
+  # Raised when the CDA limit for the app has been reached
+  class CDALimitReachedError < IntercomError; end
+
   # Raised when multiple users match the query (typically duplicate email addresses)
   class MultipleMatchingUsersError < IntercomError; end
 
+  # Raised when restoring a blocked user
+  class BlockedUserError < IntercomError; end
+
   # Raised when you try to call a non-setter method that does not exist on an object
-  class Intercom::AttributeNotSetError < IntercomError ; end
+  class Intercom::AttributeNotSetError < IntercomError; end
 
   # Raised when unexpected nil returned from server
-  class Intercom::HttpError < IntercomError ; end
+  class Intercom::HttpError < IntercomError; end
+
+  # Raised when an invalid api version is used
+  class ApiVersionInvalid < IntercomError; end
+
+  # Raised when an creating a scroll if one already exists
+  class ScrollAlreadyExistsError < IntercomError; end
+
+  # Raised when a CDA is invalid
+  class InvalidDocumentError < IntercomError; end
 
   #
   # Non-public errors (internal to the gem)
@@ -71,4 +107,5 @@ module Intercom
   class Intercom::NoMethodMissingHandler < IntercomInternalError; end
 
   class Intercom::DeserializationError < IntercomInternalError; end
+
 end

data/lib/intercom/request.rb

@@ -3,73 +3,82 @@ require 'net/https'
 
 module Intercom
   class Request
-    attr_accessor :path, :net_http_method, :rate_limit_details
-
-    def initialize(path, net_http_method)
-      self.path = path
-      self.net_http_method = net_http_method
-    end
-
-    def set_common_headers(method, base_uri)
-      method.add_field('AcceptEncoding', 'gzip, deflate')
-    end
+    class << self
+      def get(path, params)
+        new(path, Net::HTTP::Get.new(append_query_string_to_url(path, params), default_headers))
+      end
 
-    def set_basic_auth(method, username, secret)
-      method.basic_auth(CGI.unescape(username), CGI.unescape(secret))
-    end
+      def post(path, form_data)
+        new(path, method_with_body(Net::HTTP::Post, path, form_data))
+      end
 
-    def self.get(path, params)
-      new(path, Net::HTTP::Get.new(append_query_string_to_url(path, params), default_headers))
-    end
+      def delete(path, params)
+        new(path, method_with_body(Net::HTTP::Delete, path, params))
+      end
 
-    def self.post(path, form_data)
-      new(path, method_with_body(Net::HTTP::Post, path, form_data))
-    end
+      def put(path, form_data)
+        new(path, method_with_body(Net::HTTP::Put, path, form_data))
+      end
 
-    def self.delete(path, params)
-      new(path, method_with_body(Net::HTTP::Delete, path, params))
-    end
+      private def method_with_body(http_method, path, params)
+        request = http_method.send(:new, path, default_headers)
+        request.body = params.to_json
+        request["Content-Type"] = "application/json"
+        request
+      end
 
-    def self.put(path, form_data)
-      new(path, method_with_body(Net::HTTP::Put, path, form_data))
-    end
+      private def default_headers
+        {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}"}
+      end
 
-    def self.method_with_body(http_method, path, params)
-      request = http_method.send(:new, path, default_headers)
-      request.body = params.to_json
-      request["Content-Type"] = "application/json"
-      request
+      private def append_query_string_to_url(url, params)
+        return url if params.empty?
+        query_string = params.map { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
+        url + "?#{query_string}"
+      end
     end
 
-    def self.default_headers
-      {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}"}
+    def initialize(path, net_http_method)
+      self.path = path
+      self.net_http_method = net_http_method
+      self.handle_rate_limit = false
     end
 
-    def client(uri)
-      net = Net::HTTP.new(uri.host, uri.port)
-      if uri.is_a?(URI::HTTPS)
-        net.use_ssl = true
-        net.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        net.ca_file = File.join(File.dirname(__FILE__), '../data/cacert.pem')
-      end
-      net.read_timeout = 90
-      net.open_timeout = 30
-      net
-    end
+    attr_accessor :handle_rate_limit
 
-    def execute(target_base_url=nil, username:, secret: nil)
+    def execute(target_base_url=nil, username:, secret: nil, read_timeout: 90, open_timeout: 30, api_version: nil)
+      retries = 3
       base_uri = URI.parse(target_base_url)
       set_common_headers(net_http_method, base_uri)
       set_basic_auth(net_http_method, username, secret)
+      set_api_version(net_http_method, api_version) if api_version
       begin
-        client(base_uri).start do |http|
+        client(base_uri, read_timeout: read_timeout, open_timeout: open_timeout).start do |http|
           begin
             response = http.request(net_http_method)
+
             set_rate_limit_details(response)
-            decoded_body = decode_body(response)
-            parsed_body = parse_body(decoded_body, response)
             raise_errors_on_failure(response)
+
+            parsed_body = extract_response_body(response)
+
+            return nil if parsed_body.nil?
+
+            raise_application_errors_on_failure(parsed_body, response.code.to_i) if parsed_body['type'] == 'error.list'
+
             parsed_body
+          rescue Intercom::RateLimitExceeded => e
+            if @handle_rate_limit
+              seconds_to_retry = (@rate_limit_details[:reset_at] - Time.now.utc).ceil
+              if (retries -= 1) < 0
+                raise Intercom::RateLimitExceeded.new('Rate limit retries exceeded. Please examine current API Usage.')
+              else
+                sleep seconds_to_retry unless seconds_to_retry < 0
+                retry
+              end
+            else
+              raise e
+            end
           rescue Timeout::Error
             raise Intercom::ServiceUnavailableError.new('Service Unavailable [request timed out]')
           end
@@ -79,23 +88,50 @@ module Intercom
       end
     end
 
-    def decode_body(response)
-      decode(response['content-encoding'], response.body)
-    end
+    attr_accessor :path,
+                  :net_http_method,
+                  :rate_limit_details
 
-    def parse_body(decoded_body, response)
-      parsed_body = nil
-      return parsed_body if decoded_body.nil? || decoded_body.strip.empty?
-      begin
-        parsed_body = JSON.parse(decoded_body)
-      rescue JSON::ParserError => _
-        raise_errors_on_failure(response)
+    private :path,
+            :net_http_method
+
+    private def client(uri, read_timeout:, open_timeout:)
+      net = Net::HTTP.new(uri.host, uri.port)
+      if uri.is_a?(URI::HTTPS)
+        net.use_ssl = true
+        net.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        net.ca_file = File.join(File.dirname(__FILE__), '../data/cacert.pem')
       end
-      raise_application_errors_on_failure(parsed_body, response.code.to_i) if parsed_body['type'] == 'error.list'
-      parsed_body
+      net.read_timeout = read_timeout
+      net.open_timeout = open_timeout
+      net
+    end
+
+    private def extract_response_body(response)
+      decoded_body = decode(response['content-encoding'], response.body)
+
+      json_parse_response(decoded_body, response.code)
+    end
+
+    private def decode(content_encoding, body)
+      return body if (!body) || body.empty? || content_encoding != 'gzip'
+      Zlib::GzipReader.new(StringIO.new(body)).read.force_encoding("utf-8")
     end
 
-    def set_rate_limit_details(response)
+    private def json_parse_response(str, code)
+      return nil if str.to_s.empty?
+
+      JSON.parse(str)
+    rescue JSON::ParserError
+      msg = <<~MSG.gsub(/[[:space:]]+/, " ").strip # #squish from ActiveSuppor
+        Expected a JSON response body. Instead got '#{str}'
+        with status code '#{code}'.
+      MSG
+
+      raise UnexpectedResponseError, msg
+    end
+
+    private def set_rate_limit_details(response)
       rate_limit_details = {}
       rate_limit_details[:limit] = response['X-RateLimit-Limit'].to_i if response['X-RateLimit-Limit']
       rate_limit_details[:remaining] = response['X-RateLimit-Remaining'].to_i if response['X-RateLimit-Remaining']
@@ -103,28 +139,41 @@ module Intercom
       @rate_limit_details = rate_limit_details
     end
 
-    def decode(content_encoding, body)
-      return body if (!body) || body.empty? || content_encoding != 'gzip'
-      Zlib::GzipReader.new(StringIO.new(body)).read.force_encoding("utf-8")
+    private def set_common_headers(method, base_uri)
+      method.add_field('AcceptEncoding', 'gzip, deflate')
     end
 
-    def raise_errors_on_failure(res)
-      if res.code.to_i.eql?(404)
+    private def set_basic_auth(method, username, secret)
+      method.basic_auth(CGI.unescape(username), CGI.unescape(secret))
+    end
+
+    private def set_api_version(method, api_version)
+      method.add_field('Intercom-Version', api_version)
+    end
+
+    private def raise_errors_on_failure(res)
+      code = res.code.to_i
+
+      if code == 404
         raise Intercom::ResourceNotFound.new('Resource Not Found')
-      elsif res.code.to_i.eql?(401)
+      elsif code == 401
         raise Intercom::AuthenticationError.new('Unauthorized')
-      elsif res.code.to_i.eql?(403)
+      elsif code == 403
         raise Intercom::AuthenticationError.new('Forbidden')
-      elsif res.code.to_i.eql?(500)
+      elsif code == 429
+        raise Intercom::RateLimitExceeded.new('Rate Limit Exceeded')
+      elsif code == 500
         raise Intercom::ServerError.new('Server Error')
-      elsif res.code.to_i.eql?(502)
+      elsif code == 502
         raise Intercom::BadGatewayError.new('Bad Gateway Error')
-      elsif res.code.to_i.eql?(503)
+      elsif code == 503
         raise Intercom::ServiceUnavailableError.new('Service Unavailable')
+      elsif code == 504
+        raise Intercom::GatewayTimeoutError.new('Gateway Timeout')
       end
     end
 
-    def raise_application_errors_on_failure(error_list_details, http_code)
+    private def raise_application_errors_on_failure(error_list_details, http_code)
       # Currently, we don't support multiple errors
       error_details = error_list_details['errors'].first
       error_code = error_details['type'] || error_details['code']
@@ -137,18 +186,38 @@ module Intercom
         :request_id => error_list_details['request_id']
       }
       case error_code
-      when 'unauthorized', 'forbidden'
+      when 'unauthorized', 'forbidden', 'token_not_found'
         raise Intercom::AuthenticationError.new(error_details['message'], error_context)
+      when 'token_suspended'
+        raise Intercom::AppSuspendedError.new(error_details['message'], error_context)
+      when 'token_revoked'
+        raise Intercom::TokenRevokedError.new(error_details['message'], error_context)
+      when 'token_unauthorized'
+        raise Intercom::TokenUnauthorizedError.new(error_details['message'], error_context)
       when "bad_request", "missing_parameter", 'parameter_invalid', 'parameter_not_found'
         raise Intercom::BadRequestError.new(error_details['message'], error_context)
-      when "not_found"
+      when "not_restorable"
+        raise Intercom::BlockedUserError.new(error_details['message'], error_context)
+      when "not_found", "company_not_found"
         raise Intercom::ResourceNotFound.new(error_details['message'], error_context)
+      when "admin_not_found"
+        raise Intercom::AdminNotFound.new(error_details['message'], error_context)
       when "rate_limit_exceeded"
         raise Intercom::RateLimitExceeded.new(error_details['message'], error_context)
+      when "custom_data_limit_reached"
+        raise Intercom::CDALimitReachedError.new(error_details['message'], error_context)
+      when "invalid_document"
+        raise Intercom::InvalidDocumentError.new(error_details['message'], error_context)
       when 'service_unavailable'
         raise Intercom::ServiceUnavailableError.new(error_details['message'], error_context)
       when 'conflict', 'unique_user_constraint'
         raise Intercom::MultipleMatchingUsersError.new(error_details['message'], error_context)
+      when 'resource_conflict'
+        raise Intercom::ResourceNotUniqueError.new(error_details['message'], error_context)
+      when 'intercom_version_invalid'
+        raise Intercom::ApiVersionInvalid.new(error_details['message'], error_context)
+      when 'scroll_exists'
+        raise Intercom::ScrollAlreadyExistsError.new(error_details['message'], error_context)
       when nil, ''
         raise Intercom::UnexpectedError.new(message_for_unexpected_error_without_type(error_details, parsed_http_code), error_context)
       else
@@ -156,18 +225,12 @@ module Intercom
       end
     end
 
-    def message_for_unexpected_error_with_type(error_details, parsed_http_code)
+    private def message_for_unexpected_error_with_type(error_details, parsed_http_code)
       "The error of type '#{error_details['type']}' is not recognized. It occurred with the message: #{error_details['message']} and http_code: '#{parsed_http_code}'. Please contact Intercom with these details."
     end
 
-    def message_for_unexpected_error_without_type(error_details, parsed_http_code)
+    private def message_for_unexpected_error_without_type(error_details, parsed_http_code)
       "An unexpected error occured. It occurred with the message: #{error_details['message']} and http_code: '#{parsed_http_code}'. Please contact Intercom with these details."
     end
-
-    def self.append_query_string_to_url(url, params)
-      return url if params.empty?
-      query_string = params.map { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
-      url + "?#{query_string}"
-    end
   end
 end