seam 2.0.0b5 → 2.0.0.prerelease.1

data/lib/seam/auth.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "options"
-require_relative "token"
-
-module Seam
-  module Http
-    module Auth
-      class SeamInvalidTokenError < StandardError
-        def initialize(message)
-          super("Seam received an invalid token: #{message}")
-        end
-      end
-
-      def self.get_auth_headers(api_key: nil, personal_access_token: nil, workspace_id: nil)
-        if Http::Options.seam_http_options_with_api_key?(api_key: api_key, personal_access_token: personal_access_token)
-          return get_auth_headers_for_api_key(api_key)
-        end
-
-        if Http::Options.seam_http_options_with_personal_access_token?(personal_access_token: personal_access_token, api_key: api_key,
-          workspace_id: workspace_id)
-          return get_auth_headers_for_personal_access_token(personal_access_token, workspace_id)
-        end
-
-        raise Http::Options::SeamInvalidOptionsError.new(
-          "Must specify an api_key or personal_access_token. " \
-          "Attempted reading configuration from the environment, " \
-          "but the environment variable SEAM_API_KEY is not set."
-        )
-      end
-
-      def self.get_auth_headers_for_api_key(api_key)
-        if Auth.client_session_token?(api_key)
-          raise SeamInvalidTokenError.new(
-            "A Client Session Token cannot be used as an api_key"
-          )
-        end
-
-        raise SeamInvalidTokenError.new("A JWT cannot be used as an api_key") if Auth.jwt?(api_key)
-
-        raise SeamInvalidTokenError.new("An Access Token cannot be used as an api_key") if Auth.access_token?(api_key)
-
-        if Auth.publishable_key?(api_key)
-          raise SeamInvalidTokenError.new(
-            "A Publishable Key cannot be used as an api_key"
-          )
-        end
-
-        unless Auth.seam_token?(api_key)
-          raise SeamInvalidTokenError.new(
-            "Unknown or invalid api_key format, expected token to start with #{Auth::TOKEN_PREFIX}"
-          )
-        end
-
-        {"authorization" => "Bearer #{api_key}"}
-      end
-
-      def self.get_auth_headers_for_personal_access_token(personal_access_token, workspace_id)
-        if Auth.jwt?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "A JWT cannot be used as a personal_access_token"
-          )
-        end
-
-        if Auth.client_session_token?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "A Client Session Token cannot be used as a personal_access_token"
-          )
-        end
-
-        if Auth.publishable_key?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "A Publishable Key cannot be used as a personal_access_token"
-          )
-        end
-
-        unless Auth.access_token?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "Unknown or invalid personal_access_token format, expected token to start with #{Auth::ACCESS_TOKEN_PREFIX}"
-          )
-        end
-
-        {
-          "authorization" => "Bearer #{personal_access_token}",
-          "seam-workspace" => workspace_id
-        }
-      end
-
-      def self.get_auth_headers_for_multi_workspace_personal_access_token(personal_access_token)
-        if Auth.jwt?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "A JWT cannot be used as a personal_access_token"
-          )
-        end
-
-        if Auth.client_session_token?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "A Client Session Token cannot be used as a personal_access_token"
-          )
-        end
-
-        if Auth.publishable_key?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "A Publishable Key cannot be used as a personal_access_token"
-          )
-        end
-
-        unless Auth.access_token?(personal_access_token)
-          raise SeamInvalidTokenError.new(
-            "Unknown or invalid personal_access_token format, expected token to start with #{Auth::ACCESS_TOKEN_PREFIX}"
-          )
-        end
-
-        {"authorization" => "Bearer #{personal_access_token}"}
-      end
-    end
-  end
-end

data/lib/seam/base_resource.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require_relative "deep_hash_accessor"
-
-module Seam
-  module Resources
-    class BaseResource
-      attr_accessor :data, :client
-
-      def initialize(data, client = nil)
-        @data = data
-        @client = client
-
-        @data.each do |key, value|
-          value = Seam::DeepHashAccessor.new(value) if value.is_a?(Hash)
-          instance_variable_set(:"@#{key}", value)
-        end
-      end
-
-      def update_from_response(data)
-        @data = data
-        @data.each do |key, value|
-          value = Seam::DeepHashAccessor.new(value) if value.is_a?(Hash)
-          instance_variable_set(:"@#{key}", value)
-        end
-      end
-
-      def self.load_from_response(data, client = nil)
-        if data.is_a?(Array)
-          data.map { |d| new(d, client) }
-        else
-          new(data, client)
-        end
-      end
-
-      def inspect
-        "<#{self.class.name}:#{"0x00%x" % (object_id << 1)}\n" + # rubocop:disable Style/StringConcatenation, Style/FormatString
-          instance_variables
-            .map { |k| k.to_s.sub("@", "") }
-            .filter { |k| k != "data" and k != "client" and respond_to? k }
-            .map { |k| "  #{k}=#{send(k).inspect}" }
-            .join("\n") + ">"
-      end
-
-      def self.date_accessor(*attrs)
-        attrs.each do |attr|
-          define_method(attr) do
-            value = instance_variable_get(:"@#{attr}")
-
-            raise "No value for #{attr} set" if value.nil?
-
-            parse_datetime(value)
-          end
-        end
-      end
-
-      protected
-
-      def parse_datetime(value)
-        Time.parse(value)
-      end
-    end
-  end
-end

data/lib/seam/deep_hash_accessor.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Seam
-  class DeepHashAccessor
-    def initialize(data)
-      @data = data
-      create_accessor_methods
-    end
-
-    def [](key)
-      instance_variable_get(:"@#{key}")
-    end
-
-    private
-
-    def create_accessor_methods
-      @data.each do |key, value|
-        define_singleton_method(key) do
-          process_value(value)
-        end
-      end
-    end
-
-    def process_value(value)
-      case value
-      when Hash
-        DeepHashAccessor.new(value)
-      when Array
-        value.map { |v| process_value(v) }
-      else
-        value
-      end
-    end
-  end
-end

data/lib/seam/default_endpoint.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Seam
-  DEFAULT_ENDPOINT = "https://connect.getseam.com"
-end

data/lib/seam/helpers/action_attempt.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../wait_for_action_attempt"
-
-module Seam
-  module Helpers
-    module ActionAttempt
-      def self.decide_and_wait(action_attempt, client, wait_for_action_attempt)
-        if wait_for_action_attempt == true
-          return wait_until_finished(action_attempt, client)
-        elsif wait_for_action_attempt.is_a?(Hash)
-          return wait_until_finished(action_attempt, client, timeout: wait_for_action_attempt[:timeout],
-            polling_interval: wait_for_action_attempt[:polling_interval])
-        end
-
-        action_attempt
-      end
-
-      def self.wait_until_finished(action_attempt, client, timeout: nil, polling_interval: nil)
-        timeout = timeout.nil? ? 5.0 : timeout
-        polling_interval = polling_interval.nil? ? 0.5 : polling_interval
-
-        time_waiting = 0.0
-
-        while action_attempt.status == "pending"
-          sleep(polling_interval)
-          time_waiting += polling_interval
-
-          raise Seam::ActionAttemptTimeoutError.new(action_attempt, timeout) if time_waiting > timeout
-
-          action_attempt = update_action_attempt(action_attempt, client)
-        end
-
-        raise Seam::ActionAttemptFailedError.new(action_attempt) if action_attempt.status == "error"
-
-        action_attempt
-      end
-
-      def self.update_action_attempt(action_attempt, client)
-        response = client.get("/action_attempts/get", {action_attempt_id: action_attempt.action_attempt_id})
-
-        action_attempt.update_from_response(response.body["action_attempt"])
-        action_attempt
-      end
-    end
-  end
-end

data/lib/seam/http.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "http_single_workspace"
-
-module Seam
-  module Http
-    def self.new(**args)
-      Http::SingleWorkspace.new(**args)
-    end
-
-    def self.from_api_key(api_key, endpoint: nil, wait_for_action_attempt: false)
-      Http::SingleWorkspace.from_api_key(api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt)
-    end
-
-    def self.from_personal_access_token(personal_access_token, workspace_id, endpoint: nil, wait_for_action_attempt: false)
-      Http::SingleWorkspace.from_personal_access_token(personal_access_token, workspace_id, endpoint: endpoint,
-        wait_for_action_attempt: wait_for_action_attempt)
-    end
-
-    class ApiError < StandardError
-      attr_reader :code, :status_code, :request_id, :data
-
-      def initialize(error, status_code, request_id)
-        super(error[:message])
-        @code = error[:type]
-        @status_code = status_code
-        @request_id = request_id
-        @data = error[:data]
-      end
-    end
-
-    class UnauthorizedError < ApiError
-      def initialize(request_id)
-        super({type: "unauthorized", message: "Unauthorized"}, 401, request_id)
-      end
-    end
-
-    class InvalidInputError < ApiError
-      attr_reader :validation_errors
-
-      def initialize(error, status_code, request_id)
-        super
-        @code = "invalid_input"
-        @validation_errors = error["validation_errors"] || {}
-      end
-
-      def get_validation_error_messages(param_name)
-        @validation_errors.dig(param_name, "_errors") || []
-      end
-    end
-  end
-end

data/lib/seam/http_multi_workspace.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "request"
-require_relative "parse_options"
-require_relative "lts_version"
-require_relative "version"
-require_relative "auth"
-require_relative "routes/resources/index"
-require_relative "routes/clients/index"
-require_relative "routes/routes"
-
-module Seam
-  module Http
-    class MultiWorkspace
-      attr_reader :client, :defaults
-
-      def initialize(personal_access_token:, endpoint: nil, wait_for_action_attempt: true, faraday_options: {},
-        faraday_retry_options: {})
-        @wait_for_action_attempt = wait_for_action_attempt
-        @defaults = {"wait_for_action_attempt" => wait_for_action_attempt}
-        @endpoint = Http::Options.get_endpoint(endpoint)
-        @auth_headers = Http::Auth.get_auth_headers_for_multi_workspace_personal_access_token(personal_access_token)
-        @client = Http::Request.create_faraday_client(@endpoint, @auth_headers, faraday_options,
-          faraday_retry_options)
-      end
-
-      def self.lts_version
-        Seam::LTS_VERSION
-      end
-
-      def lts_version
-        Seam::LTS_VERSION
-      end
-
-      def workspaces
-        @workspaces ||= WorkspacesProxy.new(Seam::Clients::Workspaces.new(client: @client, defaults: @defaults))
-      end
-
-      def self.from_personal_access_token(personal_access_token, endpoint: nil, wait_for_action_attempt: true, faraday_options: {}, faraday_retry_options: {})
-        new(
-          personal_access_token: personal_access_token,
-          endpoint: endpoint,
-          wait_for_action_attempt: wait_for_action_attempt,
-          faraday_options: faraday_options,
-          faraday_retry_options: faraday_retry_options
-        )
-      end
-    end
-
-    class WorkspacesProxy
-      def initialize(workspaces)
-        @workspaces = workspaces
-      end
-
-      def list(**kwargs)
-        @workspaces.list(**kwargs)
-      end
-
-      def create(**kwargs)
-        @workspaces.create(**kwargs)
-      end
-    end
-
-    private_constant :WorkspacesProxy
-  end
-end

data/lib/seam/http_single_workspace.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "request"
-require_relative "parse_options"
-require_relative "routes/resources/index"
-require_relative "routes/clients/index"
-require_relative "routes/routes"
-require_relative "version"
-require_relative "deep_hash_accessor"
-
-module Seam
-  module Http
-    class SingleWorkspace
-      include Seam::Routes
-
-      attr_reader :client, :defaults
-
-      def initialize(client: nil, api_key: nil, personal_access_token: nil, workspace_id: nil, endpoint: nil,
-        wait_for_action_attempt: true, faraday_options: {}, faraday_retry_options: {})
-        options = Http::Options.parse_options(api_key: api_key, personal_access_token: personal_access_token,
-          workspace_id: workspace_id, endpoint: endpoint)
-        @endpoint = options[:endpoint]
-        @auth_headers = options[:auth_headers]
-        @defaults = Seam::DeepHashAccessor.new({"wait_for_action_attempt" => wait_for_action_attempt})
-        @client = client || Http::Request.create_faraday_client(@endpoint, @auth_headers, faraday_options,
-          faraday_retry_options)
-
-        initialize_routes(client: @client, defaults: @defaults)
-      end
-
-      def lts_version
-        Seam::LTS_VERSION
-      end
-
-      def self.from_api_key(api_key, endpoint: nil, wait_for_action_attempt: false, faraday_options: {}, faraday_retry_options: {})
-        new(api_key: api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt,
-          faraday_options: faraday_options, faraday_retry_options: faraday_retry_options)
-      end
-
-      def self.from_personal_access_token(personal_access_token, workspace_id, endpoint: nil, wait_for_action_attempt: false, faraday_options: {}, faraday_retry_options: {})
-        new(personal_access_token: personal_access_token, workspace_id: workspace_id, endpoint: endpoint,
-          wait_for_action_attempt: wait_for_action_attempt, faraday_options: faraday_options, faraday_retry_options: faraday_retry_options)
-      end
-    end
-  end
-end

data/lib/seam/options.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "default_endpoint"
-
-module Seam
-  module Http
-    module Options
-      def self.get_endpoint(endpoint = nil)
-        endpoint || get_endpoint_from_env || Seam::DEFAULT_ENDPOINT
-      end
-
-      def self.get_endpoint_from_env
-        seam_api_url = ENV["SEAM_API_URL"]
-        seam_endpoint = ENV["SEAM_ENDPOINT"]
-
-        if seam_api_url
-          warn "\033[93mUsing the SEAM_API_URL environment variable is deprecated. Support will be removed in a later major version. Use SEAM_ENDPOINT instead.\033[0m"
-        end
-
-        if seam_api_url && seam_endpoint
-          warn "\033[93mDetected both the SEAM_API_URL and SEAM_ENDPOINT environment variables. Using SEAM_ENDPOINT.\033[0m"
-        end
-
-        seam_endpoint || seam_api_url
-      end
-
-      class SeamInvalidOptionsError < StandardError
-        def initialize(message)
-          super("Seam received invalid options: #{message}")
-        end
-      end
-
-      def self.seam_http_options_with_api_key?(api_key: nil, personal_access_token: nil)
-        return false if api_key.nil?
-
-        if personal_access_token
-          raise SeamInvalidOptionsError.new(
-            "The personal_access_token option cannot be used with the api_key option"
-          )
-        end
-
-        true
-      end
-
-      def self.seam_http_options_with_personal_access_token?(personal_access_token: nil, api_key: nil, workspace_id: nil)
-        return false if personal_access_token.nil?
-
-        if api_key
-          raise SeamInvalidOptionsError.new(
-            "The api_key option cannot be used with the personal_access_token option"
-          )
-        end
-
-        if workspace_id.nil?
-          raise SeamInvalidOptionsError.new(
-            "Must pass a workspace_id when using a personal_access_token"
-          )
-        end
-
-        true
-      end
-    end
-  end
-end

data/lib/seam/parse_options.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "auth"
-require_relative "options"
-
-module Seam
-  module Http
-    module Options
-      def self.parse_options(api_key: nil, personal_access_token: nil, workspace_id: nil, endpoint: nil)
-        api_key ||= ENV["SEAM_API_KEY"] if personal_access_token.nil?
-
-        auth_headers = Http::Auth.get_auth_headers(
-          api_key: api_key,
-          personal_access_token: personal_access_token,
-          workspace_id: workspace_id
-        )
-        endpoint = Http::Options.get_endpoint(endpoint)
-
-        {auth_headers: auth_headers, endpoint: endpoint}
-      end
-    end
-  end
-end

data/lib/seam/routes/clients/access_codes.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Seam
-  module Clients
-    class AccessCodes
-      def initialize(client:, defaults:)
-        @client = client
-        @defaults = defaults
-      end
-
-      def simulate
-        @simulate ||= Seam::Clients::AccessCodesSimulate.new(client: @client, defaults: @defaults)
-      end
-
-      def unmanaged
-        @unmanaged ||= Seam::Clients::AccessCodesUnmanaged.new(client: @client, defaults: @defaults)
-      end
-
-      def create(device_id:, allow_external_modification: nil, attempt_for_offline_device: nil, code: nil, common_code_key: nil, ends_at: nil, is_external_modification_allowed: nil, is_offline_access_code: nil, is_one_time_use: nil, max_time_rounding: nil, name: nil, prefer_native_scheduling: nil, preferred_code_length: nil, starts_at: nil, sync: nil, use_backup_access_code_pool: nil, use_offline_access_code: nil)
-        res = @client.post("/access_codes/create", {device_id: device_id, allow_external_modification: allow_external_modification, attempt_for_offline_device: attempt_for_offline_device, code: code, common_code_key: common_code_key, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, is_offline_access_code: is_offline_access_code, is_one_time_use: is_one_time_use, max_time_rounding: max_time_rounding, name: name, prefer_native_scheduling: prefer_native_scheduling, preferred_code_length: preferred_code_length, starts_at: starts_at, sync: sync, use_backup_access_code_pool: use_backup_access_code_pool, use_offline_access_code: use_offline_access_code}.compact)
-
-        Seam::Resources::AccessCode.load_from_response(res.body["access_code"])
-      end
-
-      def create_multiple(device_ids:, allow_external_modification: nil, attempt_for_offline_device: nil, behavior_when_code_cannot_be_shared: nil, code: nil, ends_at: nil, is_external_modification_allowed: nil, is_offline_access_code: nil, is_one_time_use: nil, max_time_rounding: nil, name: nil, prefer_native_scheduling: nil, preferred_code_length: nil, starts_at: nil, use_backup_access_code_pool: nil, use_offline_access_code: nil)
-        res = @client.post("/access_codes/create_multiple", {device_ids: device_ids, allow_external_modification: allow_external_modification, attempt_for_offline_device: attempt_for_offline_device, behavior_when_code_cannot_be_shared: behavior_when_code_cannot_be_shared, code: code, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, is_offline_access_code: is_offline_access_code, is_one_time_use: is_one_time_use, max_time_rounding: max_time_rounding, name: name, prefer_native_scheduling: prefer_native_scheduling, preferred_code_length: preferred_code_length, starts_at: starts_at, use_backup_access_code_pool: use_backup_access_code_pool, use_offline_access_code: use_offline_access_code}.compact)
-
-        Seam::Resources::AccessCode.load_from_response(res.body["access_codes"])
-      end
-
-      def delete(access_code_id:, device_id: nil, sync: nil)
-        @client.post("/access_codes/delete", {access_code_id: access_code_id, device_id: device_id, sync: sync}.compact)
-
-        nil
-      end
-
-      def generate_code(device_id:)
-        res = @client.post("/access_codes/generate_code", {device_id: device_id}.compact)
-
-        Seam::Resources::AccessCode.load_from_response(res.body["generated_code"])
-      end
-
-      def get(access_code_id: nil, code: nil, device_id: nil)
-        res = @client.post("/access_codes/get", {access_code_id: access_code_id, code: code, device_id: device_id}.compact)
-
-        Seam::Resources::AccessCode.load_from_response(res.body["access_code"])
-      end
-
-      def list(access_code_ids: nil, device_id: nil, user_identifier_key: nil)
-        res = @client.post("/access_codes/list", {access_code_ids: access_code_ids, device_id: device_id, user_identifier_key: user_identifier_key}.compact)
-
-        Seam::Resources::AccessCode.load_from_response(res.body["access_codes"])
-      end
-
-      def pull_backup_access_code(access_code_id:)
-        res = @client.post("/access_codes/pull_backup_access_code", {access_code_id: access_code_id}.compact)
-
-        Seam::Resources::AccessCode.load_from_response(res.body["backup_access_code"])
-      end
-
-      def update(access_code_id:, allow_external_modification: nil, attempt_for_offline_device: nil, code: nil, device_id: nil, ends_at: nil, is_external_modification_allowed: nil, is_managed: nil, is_offline_access_code: nil, is_one_time_use: nil, max_time_rounding: nil, name: nil, prefer_native_scheduling: nil, preferred_code_length: nil, starts_at: nil, sync: nil, type: nil, use_backup_access_code_pool: nil, use_offline_access_code: nil)
-        @client.post("/access_codes/update", {access_code_id: access_code_id, allow_external_modification: allow_external_modification, attempt_for_offline_device: attempt_for_offline_device, code: code, device_id: device_id, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, is_managed: is_managed, is_offline_access_code: is_offline_access_code, is_one_time_use: is_one_time_use, max_time_rounding: max_time_rounding, name: name, prefer_native_scheduling: prefer_native_scheduling, preferred_code_length: preferred_code_length, starts_at: starts_at, sync: sync, type: type, use_backup_access_code_pool: use_backup_access_code_pool, use_offline_access_code: use_offline_access_code}.compact)
-
-        nil
-      end
-
-      def update_multiple(common_code_key:, allow_external_modification: nil, code: nil, ends_at: nil, is_external_modification_allowed: nil, name: nil, prefer_native_scheduling: nil, starts_at: nil)
-        @client.post("/access_codes/update_multiple", {common_code_key: common_code_key, allow_external_modification: allow_external_modification, code: code, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, name: name, prefer_native_scheduling: prefer_native_scheduling, starts_at: starts_at}.compact)
-
-        nil
-      end
-    end
-  end
-end

data/lib/seam/routes/clients/access_codes_simulate.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Seam
-  module Clients
-    class AccessCodesSimulate
-      def initialize(client:, defaults:)
-        @client = client
-        @defaults = defaults
-      end
-
-      def create_unmanaged_access_code(code:, device_id:, name:)
-        res = @client.post("/access_codes/simulate/create_unmanaged_access_code", {code: code, device_id: device_id, name: name}.compact)
-
-        Seam::Resources::UnmanagedAccessCode.load_from_response(res.body["access_code"])
-      end
-    end
-  end
-end

data/lib/seam/routes/clients/access_codes_unmanaged.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Seam
-  module Clients
-    class AccessCodesUnmanaged
-      def initialize(client:, defaults:)
-        @client = client
-        @defaults = defaults
-      end
-
-      def convert_to_managed(access_code_id:, allow_external_modification: nil, force: nil, is_external_modification_allowed: nil, sync: nil)
-        @client.post("/access_codes/unmanaged/convert_to_managed", {access_code_id: access_code_id, allow_external_modification: allow_external_modification, force: force, is_external_modification_allowed: is_external_modification_allowed, sync: sync}.compact)
-
-        nil
-      end
-
-      def delete(access_code_id:, sync: nil)
-        @client.post("/access_codes/unmanaged/delete", {access_code_id: access_code_id, sync: sync}.compact)
-
-        nil
-      end
-
-      def get(access_code_id: nil, code: nil, device_id: nil)
-        res = @client.post("/access_codes/unmanaged/get", {access_code_id: access_code_id, code: code, device_id: device_id}.compact)
-
-        Seam::Resources::UnmanagedAccessCode.load_from_response(res.body["access_code"])
-      end
-
-      def list(device_id:, user_identifier_key: nil)
-        res = @client.post("/access_codes/unmanaged/list", {device_id: device_id, user_identifier_key: user_identifier_key}.compact)
-
-        Seam::Resources::UnmanagedAccessCode.load_from_response(res.body["access_codes"])
-      end
-
-      def update(access_code_id:, is_managed:, allow_external_modification: nil, force: nil, is_external_modification_allowed: nil)
-        @client.post("/access_codes/unmanaged/update", {access_code_id: access_code_id, is_managed: is_managed, allow_external_modification: allow_external_modification, force: force, is_external_modification_allowed: is_external_modification_allowed}.compact)
-
-        nil
-      end
-    end
-  end
-end