noresponse 2.1.13 → 2.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84db2c5e4075f4ecdee9645bc083f744be747db7e1f1aa0425cee138f6c93995
-  data.tar.gz: 467b9df984f1893478dfb6b485d59514bf99740e55858dcf8b4a84c1f3254672
+  metadata.gz: 2469d4f72cf85b77dbd86ca8a05136ff313081e86be235d86cc5190ba9141639
+  data.tar.gz: 4368344ab696f56ae59f9dc2b932f25f5e66183f6e57a3ebf398f79a0146e965
 SHA512:
-  metadata.gz: 68553881631884740225fe59bbb8b73e0c473b615f592ab387db4f64fac57123afd0ae03d2f3db319f1e483e8634620812f2d5e70dbc318510dccccc91a1e9c1
-  data.tar.gz: 49accb4c21784f3075a8749b563f173b01223d61dac34c293e07746e8fefcab09cd3aaff245c7b2413359385e6c249b7a30aae93d9848e8429ee5c6364b6dd2b
+  metadata.gz: 70c09610fdb41378166092d7af4693538817762093e6ff73df8b6333c341e0bbee290b3b8b6156140361131ac1ef716d4277aa88b75ce30fa4f3e92814810688
+  data.tar.gz: 6f120c6191d655a540ffeb3d78f9c8c093c0cb6f42eb3641f0c2c9fb35076edf4d958af2965e6f517c380500c77b562795a09928ec5e095ecf0b959b4a286577

data/lib/no_response/assessments.rb

@@ -628,6 +628,294 @@ module NoResponse
       end
     end
 
+    sig {
+      params(
+        assessment_id: ::String,
+        retries: T.nilable(Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])
+      )
+        .returns(Models::Operations::DeleteAssessmentResponse)
+    }
+    def delete(assessment_id:, retries: nil, timeout_ms: nil, http_headers: nil)
+      # delete - Delete one assessment.
+      # Deletes one assessment in the environment of your key, with its versions, evidence and outcomes and the identity-graph marks its outcomes set, and scores its account again from what remains. Afterwards the assessment answers 404 and leaves the account's history. The answer names the account and the assessment its current risk now comes from; current_assessment_id is absent when the account has no assessment with a decision left. Requires the history scope. An unknown, expired or already deleted assessment answers 404, so a repeat answers 404; to erase a whole account idempotently, use accounts.delete.
+      request = Models::Operations::DeleteAssessmentRequest.new(
+        assessment_id: assessment_id
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::DeleteAssessmentRequest,
+        base_url,
+        "/v1/assessments/{assessment_id}",
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      headers["Accept"] = "application/json"
+      headers["user-agent"] = @sdk_configuration.user_agent
+      retries ||= @sdk_configuration.retry_config
+      retries ||= Utils::RetryConfig.new(
+        backoff: Utils::BackoffStrategy.new(
+          exponent: 2.0,
+          initial_interval: 500,
+          max_elapsed_time: 30_000,
+          max_interval: 8000
+        ),
+        retry_connection_errors: true,
+        strategy: "backoff"
+      )
+      retry_options = retries.to_faraday_retry_options(initial_time: Time.now)
+      retry_options[:retry_statuses] = [408, 429, 500, 501, 502, 503, 504, 505]
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+      connection = @sdk_configuration.client.dup
+      connection.use(Utils::RetryMiddleware, retry_options)
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: "deleteAssessment",
+        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).delete(url) do |req|
+          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(
+              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")
+          @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::Shared::AssessmentDeletion)
+          result = obj
+          response = Models::Operations::DeleteAssessmentResponse.new(
+            result: result,
+            headers: http_response.headers
+          )
+
+          return response
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @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::BadRequestError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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, ["401"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @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::AuthenticationError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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, ["403"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @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::PermissionDeniedError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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, ["404"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @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::NotFoundError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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, ["409"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @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::ConflictError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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, ["429"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @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::RateLimitError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.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(
+          ::NoResponse::Models::Errors::APIStatusError.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(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      else
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "Unknown status code received"
+        )
+
+      end
+    end
+
     sig {
       params(
         body: Models::Shared::AssessmentOutcomeRequest,

data/lib/no_response/late_results.rb

@@ -39,17 +39,23 @@ module NoResponse
     # with a 5xx so NoResponse retries it. The message holds no response body
     # and no credentials.
     class ProviderActionError < StandardError
-      attr_reader :provider, :status
+      # code is the provider's error code from the response body, such as
+      # Auth0's errorCode "insufficient_scope", when it sent one.
+      attr_reader :provider, :status, :code
 
-      def initialize(provider, status, message)
+      def initialize(provider, status, message, code = nil)
         super(message)
         @provider = provider
         @status = status
+        @code = code
       end
     end
 
-    # event is the verified Webhooks::Event. action is the action taken: NONE
-    # when the policy, the event or the user id called for nothing. user_id is
+    # event is the verified Webhooks::Event. action is the action that ran:
+    # NONE when the policy, the event or the user id called for nothing. It can
+    # be stronger than the policy's action when the provider had to fall back:
+    # the auth0 provider reports BAN when it blocked the user because the
+    # tenant's plan cannot end sessions. user_id is
     # the provider user id acted on, set only when an action was taken. Answer
     # an endpoint.verification with Webhooks.verification_response(event).
     Result = Struct.new(:event, :action, :user_id, keyword_init: true)
@@ -102,12 +108,17 @@ module NoResponse
         return Result.new(event: event, action: NONE) if resolved.nil? || resolved.to_s.empty?
 
         resolved = resolved.to_s
-        if action == BAN
+        # A provider may define act(action, user_id), returning the action that
+        # ran; the auth0 provider does, to report a block it had to fall back to.
+        ran = action
+        if provider.respond_to?(:act)
+          ran = provider.act(action, resolved)
+        elsif action == BAN
           provider.ban(resolved)
         else
           provider.revoke_sessions(resolved)
         end
-        Result.new(event: event, action: action, user_id: resolved)
+        Result.new(event: event, action: ACTIONS.include?(ran) ? ran : action, user_id: resolved)
       end
 
       # Clerk Backend API. revoke_sessions lists the user's active sessions
@@ -146,8 +157,18 @@ module NoResponse
       # (PATCH /users/{id}), then does the same. Pass domain (such as
       # example.eu.auth0.com; the API is https://{domain}/api/v2) or base_url.
       # token is a Management API access token with update:users,
-      # delete:sessions and delete:refresh_tokens. A 404 on any call (user
-      # already gone) counts as done, so a repeated delivery is safe.
+      # delete:sessions, delete:refresh_tokens, read:device_credentials and
+      # delete:device_credentials. A 404 on any call (user already gone)
+      # counts as done, so a repeated delivery is safe.
+      #
+      # Auth0 offers the sessions and refresh-token endpoints on Enterprise
+      # plans only; on other plans they answer 403 feature_not_enabled. Then
+      # refresh tokens are deleted one by one through /device-credentials
+      # (types refresh_token and rotating_refresh_token), which every plan
+      # has. A login session cannot be ended, so revoke_sessions blocks the
+      # user before deleting the refresh tokens, and act reports BAN. Unblock
+      # the user in the dashboard to undo it. Any other refusal, such as 403
+      # insufficient_scope, raises.
       def auth0(token:, domain: nil, base_url: nil, http_client: nil)
         raise ArgumentError, 'auth0 needs token' if token.to_s.empty?
 
@@ -191,7 +212,9 @@ module NoResponse
         end
         status, text = perform(method, uri, headers, payload)
         return nil if allow_404 && status == 404
-        raise ProviderActionError.new(@name, status, "#{@name} #{method} #{path} answered #{status}") unless status.between?(200, 299)
+        unless status.between?(200, 299)
+          raise ProviderActionError.new(@name, status, "#{@name} #{method} #{path} answered #{status}", error_code(text))
+        end
         return nil if text.nil? || text.empty?
 
         begin
@@ -203,6 +226,17 @@ module NoResponse
 
       private
 
+      # The error code in a provider's error body: Auth0's errorCode, or a top-level code.
+      def error_code(text)
+        body = JSON.parse(text.to_s)
+        return nil unless body.is_a?(Hash)
+
+        code = body['errorCode'] || body['code']
+        code.is_a?(String) && !code.empty? ? code : nil
+      rescue JSON::ParserError
+        nil
+      end
+
       def perform(method, uri, headers, payload)
         return @http_client.call(method, uri, headers, payload) if @http_client
 
@@ -296,6 +330,8 @@ module NoResponse
     end
 
     class Auth0
+      PAGE = 100
+
       def initialize(caller_)
         @call = caller_
       end
@@ -303,15 +339,79 @@ module NoResponse
       def name = 'auth0'
 
       def revoke_sessions(user_id)
-        user = Segment.encode(user_id)
-        @call.call('DELETE', "/users/#{user}/sessions", allow_404: true)
-        @call.call('DELETE', "/users/#{user}/refresh-tokens", allow_404: true)
+        revoke(user_id)
         nil
       end
 
       def ban(user_id)
-        @call.call('PATCH', "/users/#{Segment.encode(user_id)}", body: { 'blocked' => true }, allow_404: true)
-        revoke_sessions(user_id)
+        user = Segment.encode(user_id)
+        block(user)
+        # The block already ends a session the plan cannot delete.
+        delete_sessions(user)
+        delete_refresh_tokens(user_id, user)
+        nil
+      end
+
+      # Bans or revokes and returns the action that ran: BAN when revoking had
+      # to block the user.
+      def act(action, user_id)
+        if action == BAN
+          ban(user_id)
+          return BAN
+        end
+        revoke(user_id)
+      end
+
+      private
+
+      def revoke(user_id)
+        user = Segment.encode(user_id)
+        ended = delete_sessions(user)
+        # Without the sessions API a login session survives; blocking is the only way to end it.
+        block(user) unless ended
+        delete_refresh_tokens(user_id, user)
+        ended ? REVOKE_SESSIONS : BAN
+      end
+
+      # Auth0 answers 403 feature_not_enabled when the tenant's plan does not include an endpoint.
+      def not_on_plan?(error)
+        error.status == 403 && error.code == 'feature_not_enabled'
+      end
+
+      def block(user)
+        @call.call('PATCH', "/users/#{user}", body: { 'blocked' => true }, allow_404: true)
+      end
+
+      # Ends every session; false when the plan has no sessions API.
+      def delete_sessions(user)
+        @call.call('DELETE', "/users/#{user}/sessions", allow_404: true)
+        true
+      rescue ProviderActionError => e
+        raise unless not_on_plan?(e)
+
+        false
+      end
+
+      def delete_refresh_tokens(user_id, user)
+        begin
+          @call.call('DELETE', "/users/#{user}/refresh-tokens", allow_404: true)
+          return
+        rescue ProviderActionError => e
+          raise unless not_on_plan?(e)
+        end
+        # Collect every id before deleting any, so the pages do not shift underneath.
+        ids = []
+        %w[refresh_token rotating_refresh_token].each do |type|
+          10.times do |page|
+            body = @call.call('GET', '/device-credentials',
+                              query: [['user_id', user_id], ['type', type], ['page', page.to_s], ['per_page', PAGE.to_s]],
+                              allow_404: true)
+            listed = body.is_a?(Array) ? body.grep(Hash) : []
+            ids.concat(listed.map { |c| c['id'] }.select { |id| id.is_a?(String) && !id.empty? })
+            break if listed.length < PAGE
+          end
+        end
+        ids.each { |id| @call.call('DELETE', "/device-credentials/#{ERB::Util.url_encode(id)}", allow_404: true) }
       end
     end
 

data/lib/no_response/models/operations/deleteassessment_request.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class DeleteAssessmentRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Path segment, matched case-sensitively. A value that does not match the assessment_id shape answers 404, not 400.
+        field(
+          :assessment_id,
+          ::String,
+          {'path_param': {'field_name': "assessment_id", 'style': "simple", 'explode': false}}
+        )
+
+        sig { params(assessment_id: ::String).void }
+        def initialize(assessment_id:)
+          @assessment_id = assessment_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @assessment_id == other.assessment_id
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/deleteassessment_request.rbi

@@ -0,0 +1,14 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::DeleteAssessmentRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::DeleteAssessmentRequest
+  def assessment_id
+  end
+
+  def assessment_id=(str_)
+  end
+end

data/lib/no_response/models/operations/deleteassessment_response.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class DeleteAssessmentResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::AssessmentDeletion, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::AssessmentDeletion).void }
+        def initialize(headers:, result:)
+          @headers = headers
+          @result = result
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @headers == other.headers
+          return false unless @result == other.result
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/deleteassessment_response.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::DeleteAssessmentResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::DeleteAssessmentResponse
+  def headers
+  end
+
+  def headers=(str_)
+  end
+
+  def result
+  end
+
+  def result=(str_)
+  end
+end

data/lib/no_response/models/operations.rb

@@ -10,6 +10,8 @@ module NoResponse
       autoload :CreateWebhookEndpointResponse, "no_response/models/operations/createwebhookendpoint_response.rb"
       autoload :DeleteAccountRequest, "no_response/models/operations/deleteaccount_request.rb"
       autoload :DeleteAccountResponse, "no_response/models/operations/deleteaccount_response.rb"
+      autoload :DeleteAssessmentRequest, "no_response/models/operations/deleteassessment_request.rb"
+      autoload :DeleteAssessmentResponse, "no_response/models/operations/deleteassessment_response.rb"
       autoload :DeleteIntegrationRequest, "no_response/models/operations/deleteintegration_request.rb"
       autoload :DeleteIntegrationResponse, "no_response/models/operations/deleteintegration_response.rb"
       autoload :DeleteWebhookEndpointRequest, "no_response/models/operations/deletewebhookendpoint_request.rb"

data/lib/no_response/models/shared/assessmentdeletion.rb

@@ -0,0 +1,78 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Body of the 200 answer to DELETE /v1/assessments/{assessment_id}: one of the calling tenant's assessments was deleted, with its versions, evidence, outcomes and the identity-graph marks its outcomes set. Afterwards GET /v1/assessments/{assessment_id} answers 404 and the assessment leaves the account's history. The account is scored again from what remains: account.current_assessment_id names the assessment GET /v1/accounts/{account_id} now serves its risk from, and is absent when the account has no assessment with a decision left. Deleting an assessment that is already gone answers 404.
+      class AssessmentDeletion
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The assessment that was deleted.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field(
+          :account,
+          Models::Shared::AssessmentDeletionAccount,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account"), required: true}}
+        )
+        # When the deletion took effect.
+        field(
+          :deleted_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("deleted_at"), required: true}}
+        )
+        # Version of the body shape.
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
+        )
+
+        field(
+          :deleted,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("deleted"), required: true}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            account: Models::Shared::AssessmentDeletionAccount,
+            deleted_at: ::String,
+            schema_version: ::String,
+            deleted: T::Boolean
+          )
+            .void
+        }
+        def initialize(id:, account:, deleted_at:, schema_version: "1", deleted: true)
+          @id = id
+          @account = account
+          @deleted_at = deleted_at
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+          unless deleted == true
+            raise ArgumentError, "Invalid value for deleted"
+          end
+
+          @deleted = true
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @account == other.account
+          return false unless @deleted_at == other.deleted_at
+          return false unless @schema_version == other.schema_version
+          return false unless @deleted == other.deleted
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/assessmentdeletion.rbi

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentDeletion
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentDeletion
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def account
+  end
+
+  def account=(str_)
+  end
+
+  def deleted_at
+  end
+
+  def deleted_at=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+
+  def deleted
+  end
+
+  def deleted=(str_)
+  end
+end

data/lib/no_response/models/shared/assessmentdeletionaccount.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AssessmentDeletionAccount
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The account_id of the deleted assessment.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # The assessment the account's current risk now comes from. Absent when the account has no assessment with a decision left, and GET /v1/accounts/{account_id} then answers 404.
+        field(
+          :current_assessment_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("current_assessment_id")}}
+        )
+
+        sig { params(id: ::String, current_assessment_id: T.nilable(::String)).void }
+        def initialize(id:, current_assessment_id: nil)
+          @id = id
+          @current_assessment_id = current_assessment_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @current_assessment_id == other.current_assessment_id
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/assessmentdeletionaccount.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentDeletionAccount
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentDeletionAccount
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def current_assessment_id
+  end
+
+  def current_assessment_id=(str_)
+  end
+end

data/lib/no_response/models/shared.rb

@@ -12,6 +12,8 @@ module NoResponse
       autoload :AccountRiskReason, "no_response/models/shared/accountriskreason.rb"
       autoload :Assessment, "no_response/models/shared/assessment.rb"
       autoload :AssessmentAuthContext, "no_response/models/shared/assessmentauthcontext.rb"
+      autoload :AssessmentDeletion, "no_response/models/shared/assessmentdeletion.rb"
+      autoload :AssessmentDeletionAccount, "no_response/models/shared/assessmentdeletionaccount.rb"
       autoload :AssessmentFlow, "no_response/models/shared/assessmentflow.rb"
       autoload :AssessmentList, "no_response/models/shared/assessmentlist.rb"
       autoload :AssessmentOutcome, "no_response/models/shared/assessmentoutcome.rb"

data/lib/no_response/sdkconfiguration.rb

@@ -95,9 +95,9 @@ module NoResponse
 
       @language = "ruby"
       @openapi_doc_version = "1"
-      @sdk_version = "2.1.13"
+      @sdk_version = "2.1.15"
       @gen_version = "internal"
-      @user_agent = "noresponse-sdk/ruby 2.1.13 internal 1 noresponse"
+      @user_agent = "noresponse-sdk/ruby 2.1.15 internal 1 noresponse"
     end
 
     sig { returns([String, T::Hash[Symbol, String]]) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noresponse
 version: !ruby/object:Gem::Version
-  version: 2.1.13
+  version: 2.1.15
 platform: ruby
 authors:
 - NoResponse
@@ -288,6 +288,10 @@ files:
 - lib/no_response/models/operations/deleteaccount_request.rbi
 - lib/no_response/models/operations/deleteaccount_response.rb
 - lib/no_response/models/operations/deleteaccount_response.rbi
+- lib/no_response/models/operations/deleteassessment_request.rb
+- lib/no_response/models/operations/deleteassessment_request.rbi
+- lib/no_response/models/operations/deleteassessment_response.rb
+- lib/no_response/models/operations/deleteassessment_response.rbi
 - lib/no_response/models/operations/deleteintegration_request.rb
 - lib/no_response/models/operations/deleteintegration_request.rbi
 - lib/no_response/models/operations/deleteintegration_response.rb
@@ -361,6 +365,10 @@ files:
 - lib/no_response/models/shared/assessment.rbi
 - lib/no_response/models/shared/assessmentauthcontext.rb
 - lib/no_response/models/shared/assessmentauthcontext.rbi
+- lib/no_response/models/shared/assessmentdeletion.rb
+- lib/no_response/models/shared/assessmentdeletion.rbi
+- lib/no_response/models/shared/assessmentdeletionaccount.rb
+- lib/no_response/models/shared/assessmentdeletionaccount.rbi
 - lib/no_response/models/shared/assessmentflow.rb
 - lib/no_response/models/shared/assessmentflow.rbi
 - lib/no_response/models/shared/assessmentlist.rb