authlete_ruby_test 0.0.1.beta

data/lib/authlete/device_flow.rb

@@ -0,0 +1,647 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'faraday/retry'
+require 'sorbet-runtime'
+require_relative 'sdk_hooks/hooks'
+require_relative 'utils/retries'
+
+module Authlete
+  extend T::Sig
+  class DeviceFlow
+    extend T::Sig
+    
+
+
+    sig { params(sdk_config: SDKConfiguration).void }
+    def initialize(sdk_config)
+      @sdk_configuration = sdk_config
+      
+    end
+
+    sig { params(base_url: String, url_variables: T.nilable(T::Hash[Symbol, T.any(String, T::Enum)])).returns(String) }
+    def get_url(base_url:, url_variables: nil)
+      sd_base_url, sd_options = @sdk_configuration.get_server_details
+
+      if base_url.nil?
+        base_url = sd_base_url
+      end
+
+      if url_variables.nil?
+        url_variables = sd_options
+      end
+
+      return Utils.template_url base_url, url_variables
+    end
+
+
+    sig { params(device_authorization_request: Models::Components::DeviceAuthorizationRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::DeviceAuthorizationApiResponse) }
+    def authorization(device_authorization_request:, service_id:, timeout_ms: nil)
+      # authorization - Process Device Authorization Request
+      # This API parses request parameters of a [device authorization request](https://datatracker.ietf.org/doc/html/rfc8628#section-3.1)
+      # and returns necessary data for the authorization server implementation to process the device authorization
+      # request further.
+      # ### Description
+      # This API is supposed to be called from the within the implementation of the device authorization
+      # endpoint of the service. The service implementation should retrieve the value of `action` from the
+      # response and take the following steps according to the value.
+      # **INTERNAL\_SERVER\_ERROR**
+      # When the value of `action` is `INTERNAL\_SERVER\_ERROR`, it means that the API call from the authorization
+      # server implementation was wrong or that an error occurred in Authlete.
+      # In either case, from a viewpoint of the client application, it is an error on the server side.
+      # Therefore, the authorization server implementation should generate a response to the client application
+      # with "500 Internal Server Error"s and `application/json`.
+      # The value of `responseContent` is a JSON string which describes t he error, so it can be
+      # used as the entity body of the response.
+      # The following illustrates the response which the authorization server implementation should generate
+      # and return to the client application.
+      # ```
+      # HTTP/1.1 500 Internal Server Error
+      # Content-Type: application/json
+      # Cache-Control: no-store
+      # Pragma: no-cache
+      # {responseContent}
+      # ```
+      # **BAD\_REQUEST**
+      # When the value of `action` is `BAD\_REQUEST`, it means that the request from the client application
+      # is wrong.
+      # The authorization server implementation should generate a response to the client application with
+      # "400 Bad Request" and `application/json`.
+      # The value of `responseContent` is a JSON string which describes the error, so it can be used as
+      # the entity body of the response.
+      # The following illustrates the response which the service implementation should generate and return
+      # to the client application.
+      # ```
+      # HTTP/1.1 400 Bad Request
+      # Content-Type: application/json
+      # Cache-Control: no-store
+      # Pragma: no-cache
+      # {responseContent}
+      # ```
+      # **UNAUTHORIZED**
+      # When the value of `action` is `UNAUTHORIZED`, it means that client authentication of the device authorization
+      # request failed.
+      # The authorization server implementation should generate a response to the client application with
+      # "401 Unauthorized" and `application/json`.
+      # The value of `responseContent` is a JSON string which describes the error, so it can be used as
+      # the entity body of the response.
+      # The following illustrates the response which the service implementation must generate and return
+      # to the client application.
+      # ```
+      # HTTP/1.1 401 Unauthorized
+      # WWW-Authenticate: (challenge)
+      # Content-Type: application/json
+      # Cache-Control: no-store
+      # Pragma: no-cache
+      # {responseContent}
+      # ```
+      # **OK**
+      # When the value of `action` is `OK`, it means that the device authorization request from the client
+      # application is valid.
+      # The authorization server implementation should generate a response to the client application with
+      # "200 OK" and `application/json`.
+      # The `responseContent` is a JSON string which can be used as the entity body of the response.
+      # The following illustrates the response which the authorization server implementation should generate
+      # and return to the client application.
+      # 
+      request = Models::Operations::DeviceAuthorizationApiRequest.new(
+        service_id: service_id,
+        device_authorization_request: device_authorization_request
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::DeviceAuthorizationApiRequest,
+        base_url,
+        '/api/{serviceId}/device/authorization',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :device_authorization_request, :json)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+
+      if form
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: [],
+        operation_id: 'device_authorization_api',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::DeviceAuthorizationResponse)
+          response = Models::Operations::DeviceAuthorizationApiResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            device_authorization_response: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400', '401', '403'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ResultError)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['500'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ResultError)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
+    sig { params(device_verification_request: Models::Components::DeviceVerificationRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::DeviceVerificationApiResponse) }
+    def verification(device_verification_request:, service_id:, timeout_ms: nil)
+      # verification - Process Device Verification Request
+      # The API returns information associated with a user code.
+      # ### Description
+      # After receiving a response from the device authorization endpoint of the authorization server,
+      # the client application shows the end-user the user code and the verification URI which are included
+      # in the device authorization response. Then, the end-user will access the verification URI using
+      # a web browser on another device (typically, a smart phone). In normal implementations, the verification
+      # endpoint will return an HTML page with an input form where the end-user inputs a user code. The
+      # authorization server will receive a user code from the form.
+      # After receiving a user code, the authorization server should call Authlete's `/device/verification`
+      # API with the user code. And then, the authorization server implementation should retrieve the value
+      # of `action` parameter from the API response and take the following steps according to the value.
+      # **SERVER\_ERROR**
+      # When the value of `action` is `SERVER\_ERROR`, it means that an error occurred on Authlete side. The
+      # authorization server implementation should tell the end-user that something wrong happened and
+      # urge her to re-initiate a device flow.
+      # **NOT\_EXIST**
+      # When the value of `action` is `NOT\_EXIST`, it means that the user code does not exist. The authorization
+      # server implementation should tell the end-user that the user code is invalid and urge her to retry
+      # to input a valid user code.
+      # **EXPIRED**
+      # When the value of `action` is `EXPIRED`, it means that the user code has expired. The authorization
+      # server implementation should tell the end-user that the user code has expired and urge her to
+      # re-initiate a device flow.
+      # **VALID**
+      # When the value of `action` is `VALID`, it means that the user code exists, has not expired, and
+      # belongs to the service. The authorization server implementation should interact with the end-user
+      # to ask whether she approves or rejects the authorization request from the device.
+      # 
+      request = Models::Operations::DeviceVerificationApiRequest.new(
+        service_id: service_id,
+        device_verification_request: device_verification_request
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::DeviceVerificationApiRequest,
+        base_url,
+        '/api/{serviceId}/device/verification',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :device_verification_request, :json)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+
+      if form
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: [],
+        operation_id: 'device_verification_api',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::DeviceVerificationResponse)
+          response = Models::Operations::DeviceVerificationApiResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            device_verification_response: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400', '401', '403'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ResultError)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['500'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ResultError)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
+    sig { params(device_complete_request: Models::Components::DeviceCompleteRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::DeviceCompleteApiResponse) }
+    def complete_request(device_complete_request:, service_id:, timeout_ms: nil)
+      # complete_request - Complete Device Authorization
+      # This API returns information about what action the authorization server should take after it receives
+      # the result of end-user's decision about whether the end-user has approved or rejected a client
+      # application's request.
+      # ### Description
+      # In the device flow, an end-user accesses the verification endpoint of the authorization server where
+      # she interacts with the verification endpoint and inputs a user code. The verification endpoint checks
+      # if the user code is valid and then asks the end-user whether she approves or rejects the authorization
+      # request which the user code represents.
+      # After the authorization server receives the decision of the end-user, it should call Authlete's
+      # `/device/complete` API to tell Authlete the decision.
+      # When the end-user was authenticated and authorization was granted to the client by the end-user,
+      # the authorization server should call the API with `result=AUTHORIZED`. In this successful case,
+      # the subject request parameter is mandatory. The API will update the database record so that `/auth/token`
+      # API can generate an access token later.
+      # If the `scope` parameter of the device authorization request included the openid scope, an ID token
+      # is generated. In this case, `sub`, `authTime`, `acr` and `claims` request parameters in the API
+      # call to `/device/complete` affect the ID token.
+      # When the authorization server receives the decision of the end-user and it indicates that she has
+      # rejected to give authorization to the client, the authorization server should call the API with
+      # `result=ACCESS\_DENIED`. In this case, the API will update the database record so that the `/auth/token`
+      # API can generate an error response later. If `errorDescription` and `errorUri` request parameters
+      # are given to the `/device/complete` API, they will be used as the values of `error\_description`
+      # and `error\_uri` response parameters in the error response from the token endpoint.
+      # When the authorization server could not get decision from the end-user for some reasons, the authorization
+      # server should call the API with `result=TRANSACTION\_FAILED`. In this error case, the API will behave
+      # in the same way as in the case of `ACCESS\_DENIED`. The only difference is that `expired\_token` is
+      # used as the value of the `error` response parameter instead of `access\_denied`.
+      # After receiving a response from the `/device/complete` API, the implementation of the authorization
+      # server should retrieve the value of `action` from the response and take the following steps according
+      # to the value.
+      # **SERVER\_ERROR**
+      # When the value of `action` is `SERVER\_ERROR`, it means that an error occurred on Authlete side. The
+      # authorization server implementation should tell the end-user that something wrong happened and
+      # urge her to re-initiate a device flow.
+      # **USER\_CODE\_NOT\_EXIST**
+      # When the value of `action` is `USER\_CODE\_NOT\_EXIST`, it means that the user code included in the API
+      # call does not exist. The authorization server implementation should tell the end-user that the user
+      # code has been invalidated and urge her to re-initiate a device flow.
+      # **USER\_CODE\_EXPIRED**
+      # When the value of `action` is `USER\_CODE\_EXPIRED`, it means that the user code included in the API
+      # call has expired. The authorization server implementation should tell the end-user that the user
+      # code has expired and urge her to re-initiate a device flow.
+      # **INVALID\_REQUEST**
+      # When the value of `action` is `INVALID\_REQUEST`, it means that the API call is invalid. Probably,
+      # the authorization server implementation has some bugs.
+      # **SUCCESS**
+      # When the value of `action` is `SUCCESS`, it means that the API call has been processed successfully.
+      # The authorization server should return a successful response to the web browser the end-user is
+      # using.
+      # 
+      request = Models::Operations::DeviceCompleteApiRequest.new(
+        service_id: service_id,
+        device_complete_request: device_complete_request
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::DeviceCompleteApiRequest,
+        base_url,
+        '/api/{serviceId}/device/complete',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :device_complete_request, :json)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+
+      if form
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: [],
+        operation_id: 'device_complete_api',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::DeviceCompleteResponse)
+          response = Models::Operations::DeviceCompleteApiResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            device_complete_response: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400', '401', '403'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ResultError)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['500'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ResultError)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Authlete::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+  end
+end