authlete_ruby_sdk 0.0.2.beta → 0.0.5.pre.beta

data/lib/authlete/clients.rb

@@ -39,11 +39,13 @@ module Authlete
     end
 
 
-    sig { params(service_id: ::String, client_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::ClientGetApiResponse) }
-    def retrieve(service_id:, client_id:, timeout_ms: nil)
+
+
+    sig { params(service_id: ::String, client_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ClientGetApiResponse) }
+    def retrieve(service_id:, client_id:, timeout_ms: nil, http_headers: nil)
       # retrieve - Get Client
       # Get a client.
-      # 
+      #
       request = Models::Operations::ClientGetApiRequest.new(
         service_id: service_id,
         client_id: client_id
@@ -86,6 +88,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -183,16 +188,16 @@ module Authlete
     end
 
 
-    sig { params(service_id: ::String, developer: T.nilable(::String), start: T.nilable(::Integer), end_: T.nilable(::Integer), timeout_ms: T.nilable(Integer)).returns(Models::Operations::ClientGetListApiResponse) }
-    def list(service_id:, developer: nil, start: nil, end_: nil, timeout_ms: nil)
+    sig { params(service_id: ::String, developer: T.nilable(::String), start: T.nilable(::Integer), end_: T.nilable(::Integer), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ClientGetListApiResponse) }
+    def list(service_id:, developer: nil, start: nil, end_: nil, timeout_ms: nil, http_headers: nil)
       # list - List Clients
       # Get a list of clients on a service.
-      # 
+      #
       # If the access token can view a full service (including an admin), all clients within the
       # service are returned. Otherwise, only clients that the access token can view within the
       # service are returned.
       # - ViewClient: []
-      # 
+      #
       request = Models::Operations::ClientGetListApiRequest.new(
         service_id: service_id,
         developer: developer,
@@ -239,6 +244,9 @@ module Authlete
           req.options.timeout = timeout unless timeout.nil?
           req.params = query_params
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -336,11 +344,11 @@ module Authlete
     end
 
 
-    sig { params(service_id: ::String, client: T.nilable(Models::Components::ClientInput), timeout_ms: T.nilable(Integer)).returns(Models::Operations::ClientCreateApiResponse) }
-    def create(service_id:, client: nil, timeout_ms: nil)
+    sig { params(service_id: ::String, client: T.nilable(Models::Components::ClientInput), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ClientCreateApiResponse) }
+    def create(service_id:, client: nil, timeout_ms: nil, http_headers: nil)
       # create - Create Client
       # Create a new client.
-      # 
+      #
       request = Models::Operations::ClientCreateApiRequest.new(
         service_id: service_id,
         client: client
@@ -358,7 +366,7 @@ module Authlete
       req_content_type, data, form = Utils.serialize_request_body(request, false, false, :client, :json)
       headers['content-type'] = req_content_type
 
-      if form
+      if form && !form.empty?
         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]))
@@ -394,6 +402,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -429,7 +440,7 @@ module Authlete
       end
       
       content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
-      if Utils.match_status_code(http_response.status, ['200'])
+      if Utils.match_status_code(http_response.status, ['200', '201'])
         if Utils.match_content_type(content_type, 'application/json')
           http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
@@ -491,11 +502,11 @@ module Authlete
     end
 
 
-    sig { params(service_id: ::String, client_id: ::String, client: T.nilable(Models::Components::ClientInput), timeout_ms: T.nilable(Integer)).returns(Models::Operations::ClientUpdateApiResponse) }
-    def update(service_id:, client_id:, client: nil, timeout_ms: nil)
+    sig { params(service_id: ::String, client_id: ::String, client: T.nilable(Models::Components::ClientInput), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ClientUpdateApiResponse) }
+    def update(service_id:, client_id:, client: nil, timeout_ms: nil, http_headers: nil)
       # update - Update Client
       # Update a client.
-      # 
+      #
       request = Models::Operations::ClientUpdateApiRequest.new(
         service_id: service_id,
         client_id: client_id,
@@ -514,7 +525,7 @@ module Authlete
       req_content_type, data, form = Utils.serialize_request_body(request, false, false, :client, :json)
       headers['content-type'] = req_content_type
 
-      if form
+      if form && !form.empty?
         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]))
@@ -550,6 +561,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -636,7 +650,7 @@ module Authlete
         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'])
+      elsif Utils.match_status_code(http_response.status, ['404', '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'
@@ -647,11 +661,11 @@ module Authlete
     end
 
 
-    sig { params(service_id: ::String, client_id: ::String, request_body: T.nilable(T::Hash[Symbol, ::Object]), timeout_ms: T.nilable(Integer)).returns(Models::Operations::ClientUpdateApiFormResponse) }
-    def update_form(service_id:, client_id:, request_body: nil, timeout_ms: nil)
+    sig { params(service_id: ::String, client_id: ::String, request_body: T.nilable(T::Hash[Symbol, ::Object]), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ClientUpdateApiFormResponse) }
+    def update_form(service_id:, client_id:, request_body: nil, timeout_ms: nil, http_headers: nil)
       # update_form - Update Client
       # Update a client.
-      # 
+      #
       request = Models::Operations::ClientUpdateApiFormRequest.new(
         service_id: service_id,
         client_id: client_id,
@@ -670,7 +684,7 @@ module Authlete
       req_content_type, data, form = Utils.serialize_request_body(request, false, false, :request_body, :form)
       headers['content-type'] = req_content_type
 
-      if form
+      if form && !form.empty?
         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]))
@@ -706,6 +720,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -792,7 +809,7 @@ module Authlete
         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'])
+      elsif Utils.match_status_code(http_response.status, ['404', '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'
@@ -803,11 +820,11 @@ module Authlete
     end
 
 
-    sig { params(service_id: ::String, client_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::ClientDeleteApiResponse) }
-    def destroy(service_id:, client_id:, timeout_ms: nil)
+    sig { params(service_id: ::String, client_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ClientDeleteApiResponse) }
+    def destroy(service_id:, client_id:, timeout_ms: nil, http_headers: nil)
       # destroy - Delete Client ⚡
       # Delete a client.
-      # 
+      #
       request = Models::Operations::ClientDeleteApiRequest.new(
         service_id: service_id,
         client_id: client_id
@@ -850,6 +867,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -927,7 +947,7 @@ module Authlete
         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'])
+      elsif Utils.match_status_code(http_response.status, ['404', '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'
@@ -936,5 +956,5 @@ module Authlete
 
       end
     end
-  end
+end
 end

data/lib/authlete/device_flow.rb

@@ -39,75 +39,15 @@ module Authlete
     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)
+
+
+    sig { params(device_authorization_request: Models::Components::DeviceAuthorizationRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::DeviceAuthorizationApiResponse) }
+    def authorization(device_authorization_request:, service_id:, timeout_ms: nil, http_headers: 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
@@ -126,7 +66,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         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]))
@@ -162,6 +102,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -259,37 +202,11 @@ module Authlete
     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)
+    sig { params(device_verification_request: Models::Components::DeviceVerificationRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::DeviceVerificationApiResponse) }
+    def verification(device_verification_request:, service_id:, timeout_ms: nil, http_headers: 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
@@ -308,7 +225,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         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]))
@@ -344,6 +261,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -441,59 +361,13 @@ module Authlete
     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)
+    sig { params(device_complete_request: Models::Components::DeviceCompleteRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::DeviceCompleteApiResponse) }
+    def complete_request(device_complete_request:, service_id:, timeout_ms: nil, http_headers: 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
@@ -512,7 +386,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         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]))
@@ -548,6 +422,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -643,5 +520,5 @@ module Authlete
 
       end
     end
-  end
+end
 end