noresponse 2.1.15 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2469d4f72cf85b77dbd86ca8a05136ff313081e86be235d86cc5190ba9141639
-  data.tar.gz: 4368344ab696f56ae59f9dc2b932f25f5e66183f6e57a3ebf398f79a0146e965
+  metadata.gz: 9ba556406e80e6bb7f20aeee106cc215b9872a1fbd1816663d6da76af9c1d568
+  data.tar.gz: 3c1214f820469af0cdc955ad85c6526edb30144fdf937f4a41f896f47b0b84cc
 SHA512:
-  metadata.gz: 70c09610fdb41378166092d7af4693538817762093e6ff73df8b6333c341e0bbee290b3b8b6156140361131ac1ef716d4277aa88b75ce30fa4f3e92814810688
-  data.tar.gz: 6f120c6191d655a540ffeb3d78f9c8c093c0cb6f42eb3641f0c2c9fb35076edf4d958af2965e6f517c380500c77b562795a09928ec5e095ecf0b959b4a286577
+  metadata.gz: 0023bb0cc6f1a40b655291291b9f06a478216cf395cde6e734497fbde1b3f304dac4e9fee9f9e9a9f2c779a013cf07b543bec5dbb27a09a90077a275cd763ff0
+  data.tar.gz: 79758d27c28ddf6630ac6e7e33db49011e4b19f56c1e272fe85d3d32f67a806f246d16dfa5a459121c1f69463d5a8cab4bdd31b2b3b0c70485caa0196db162dc

data/lib/no_response/accounts.rb

@@ -49,7 +49,7 @@ module NoResponse
     }
     def get(account_id:, retries: nil, timeout_ms: nil, http_headers: nil)
       # get - Read an account's one current risk.
-      # An account is the account_id you send with your assessments. Its current risk is the risk of its latest assessment with a decision (status complete or partial), scored as GET /v1/assessments/{assessment_id} scores that assessment, with a decision for each flow. Every assessment updates its account: once an assessment completes, the account carries its risk. Requires the history scope. Read-only and safe to retry. An account with no unexpired assessment that has a decision answers 404 not_found, and a malformed account_id answers 400 invalid_request.
+      # An account is the account_id you send with your assessments. Its current risk is the risk of its latest assessment with a decision (status complete or partial), scored as GET /v1/assessments/{assessment_id} scores that assessment, with a decision for each flow; risk.decision is the decision for the flow of that assessment. Every assessment answers with this same account. Every assessment updates its account: once an assessment completes, the account carries its risk. Requires the history scope. Read-only and safe to retry. An account with no unexpired assessment that has a decision answers 404 not_found, and a malformed account_id answers 400 invalid_request.
       request = Models::Operations::GetAccountRequest.new(
         account_id: account_id
       )

data/lib/no_response/assessments.rb

@@ -50,7 +50,7 @@ module NoResponse
     }
     def create(body:, idempotency_key: nil, retries: nil, timeout_ms: nil, http_headers: nil)
       # create - Assess identifiers for a signup or gateway decision.
-      # Returns within the deadline (3000 ms at most) with a complete, partial or pending assessment: 200 carries complete or partial, 202 carries pending with Location and Retry-After. A pending answer has no recommendation; apply your own fallback for pending, 429, 503 or a timeout. risk.block says when your block threshold was reached. Requires the assess scope. Idempotency-Key is optional in the SDK and is bound to the body for 24 hours: the same key with the same body replays the latest assessment with Idempotent-Replayed: true and starts no new work; the same key with a different body answers 409 idempotency_key_reused. response_mode defaults to standard; detailed needs the detailed scope.
+      # Assesses one signup, login or purchase (flow) and answers with the account's one current risk: account.risk.decision is the decision for this flow (allow, step_up, review or block, where block means your block threshold was reached), and detail holds this assessment's own facts. depth sets how long the answer waits for sources: quick waits only for the fast ones (500 ms), full for the whole budget (3000 ms at most); it defaults to full for signup and purchase and quick for login. 200 carries complete or partial, 202 carries pending with Location and Retry-After. While the account's first assessment is pending, account is absent: apply your own fallback for that, 429, 503 or a timeout. NoResponse blocks nothing itself; you decide. Requires the assess scope. Idempotency-Key is optional in the SDK and is bound to the body for 24 hours: the same key with the same body replays the latest assessment with Idempotent-Replayed: true and starts no new work; the same key with a different body answers 409 idempotency_key_reused. response_mode defaults to standard; detailed needs the detailed scope.
       request = Models::Operations::CreateAssessmentRequest.new(
         body: body,
         idempotency_key: idempotency_key
@@ -348,7 +348,7 @@ module NoResponse
     }
     def get(assessment_id:, response_mode: nil, retries: nil, timeout_ms: nil, http_headers: nil)
       # get - Poll the authoritative assessment of one assessment.
-      # Returns the highest assessment_version. Requires the assess or history scope. While status is pending, or partial with a source still running, the response carries Retry-After; poll no faster than it says. Another tenant's assessment, an unknown or expired assessment and a malformed assessment_id all answer 404 not_found. response_mode=detailed needs the detailed scope.
+      # Returns the highest assessment_version, with the account's current risk. Requires the assess or history scope. While status is pending, or partial with a source still running, the response carries Retry-After; poll no faster than it says. Another tenant's assessment, an unknown or expired assessment and a malformed assessment_id all answer 404 not_found. response_mode=detailed needs the detailed scope.
       request = Models::Operations::GetAssessmentRequest.new(
         assessment_id: assessment_id,
         response_mode: response_mode

data/lib/no_response/late_results.rb

@@ -4,7 +4,7 @@
 # Late-result handlers. Hand-written beside the generated client.
 #
 # An assessment can be revised after the signup was allowed: a slow source
-# settles and the recommendation rises. NoResponse sends the new version as a
+# settles and the account's decision rises. NoResponse sends the new version as a
 # signed assessment.updated webhook. LateResults.handle verifies that delivery
 # with Webhooks.construct_event, picks an action from your policy, and acts
 # through the auth provider's admin API: revoke the user's sessions or ban the
@@ -30,10 +30,12 @@ module NoResponse
     BAN = 'ban'
     ACTIONS = [NONE, REVOKE_SESSIONS, BAN].freeze
 
-    # Revoke sessions on review; do nothing on allow or step_up. Banning is opt-in.
-    DEFAULT_POLICY = { 'allow' => NONE, 'step_up' => NONE, 'review' => REVOKE_SESSIONS }.freeze
+    # Revoke sessions on review and block; do nothing on allow or step_up.
+    # Banning is opt-in.
+    DEFAULT_POLICY = { 'allow' => NONE, 'step_up' => NONE, 'review' => REVOKE_SESSIONS,
+                       'block' => REVOKE_SESSIONS }.freeze
 
-    RECOMMENDATIONS = %w[allow step_up review].freeze
+    DECISIONS = %w[allow step_up review block].freeze
 
     # Raised when the provider's admin API refuses a call. Answer the webhook
     # with a 5xx so NoResponse retries it. The message holds no response body
@@ -61,23 +63,25 @@ module NoResponse
     Result = Struct.new(:event, :action, :user_id, keyword_init: true)
 
     class << self
-      # The action your policy names for a verified event. Only a served
-      # assessment with a recommendation can act; a test event never does.
-      # policy maps allow, step_up and review (as strings or symbols) to NONE,
-      # REVOKE_SESSIONS or BAN; a recommendation you leave out does nothing. An
-      # unknown action raises ArgumentError.
+      # The action your policy names for a verified event, from the account's
+      # decision (data.account.risk.decision). Only a served assessment whose
+      # account has a decision can act; a pending assessment, an expiry and a
+      # test event never do. policy maps allow, step_up, review and block (as
+      # strings or symbols) to NONE, REVOKE_SESSIONS or BAN; a decision you
+      # leave out does nothing. An unknown action raises ArgumentError.
       def action_for(event, policy = DEFAULT_POLICY)
         return NONE if event.type != 'assessment.updated' || event.test? || event.expired?
 
         data = event.data
-        recommendation = data.recommendation || data.risk&.recommendation
-        recommendation = recommendation.to_s
-        return NONE unless RECOMMENDATIONS.include?(recommendation)
+        return NONE if data.status == Models::Shared::Status::PENDING || data.account.nil?
+
+        decision = data.account.risk.decision.to_s
+        return NONE unless DECISIONS.include?(decision)
 
         table = policy.to_h.transform_keys(&:to_s)
-        return NONE unless table.key?(recommendation)
+        return NONE unless table.key?(decision)
 
-        action = table[recommendation]
+        action = table[decision]
         return NONE if action.nil?
 
         action = action.to_s
@@ -103,7 +107,7 @@ module NoResponse
         action = action_for(event, policy)
         return Result.new(event: event, action: NONE) if action == NONE || event.type != 'assessment.updated'
 
-        account_id = event.data.account_id
+        account_id = event.data.detail.account_id
         resolved = user_id ? user_id.call(account_id, event) : account_id
         return Result.new(event: event, action: NONE) if resolved.nil? || resolved.to_s.empty?
 

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

@@ -17,7 +17,7 @@ module NoResponse
           Models::Shared::AccountRisk,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("risk"), required: true}}
         )
-        # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three equal risk.decision.
+        # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three are equal.
         field(
           :decisions_by_flow,
           Models::Shared::AccountDecisionsByFlow,

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three equal risk.decision.
+      # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three are equal.
       class AccountDecisionsByFlow
         extend T::Sig
         include Crystalline::MetadataFields

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

@@ -4,23 +4,13 @@
 module NoResponse
   module Models
     module Shared
-      # One assessment of one account, as POST /v1/assessments, GET /v1/assessments/{assessment_id} and the assessment.updated webhook return it. status says whether it is final (complete), usable with a source still running (partial) or not yet usable (pending). risk and recommendation are present for complete and partial; assessment_url is present for pending. Keep the highest assessment_version.
+      # One assessment, as POST /v1/assessments, GET /v1/assessments/{assessment_id} and the assessment.updated webhook return it. account is the account's one current risk: its score, the decision for this assessment's flow, the reasons and the decision for each flow. detail holds this assessment's own facts. status says whether the assessment is final (complete), usable with a source still running (partial) or not yet usable (pending). While the account's first assessment is pending, account is absent; wait for the webhook or poll the assessment. Keep the highest detail.assessment_version.
       class Assessment
         extend T::Sig
         include Crystalline::MetadataFields
 
-        # Opaque, server-assigned assessment id: 'asm_' and a 26-character Crockford base32 ULID. Unique within the tenant; another tenant's assessment id answers 404.
-        field(
-          :assessment_id,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessment_id"), required: true}}
-        )
-        # Your own opaque identifier for the account being checked, scoped to your tenant. Use an id you mint, with no direct identifier (email, phone, name or national id) in it. '|' is accepted so an Auth0 user id such as 'auth0|64abc' passes unchanged; '@', '+', '$' and whitespace are refused by the pattern, as is an exact-shape JWT; a hex digest such as a SHA-256 is allowed, because hashing an internal id is a common pseudonymous scheme. A value such as '07700900123' or 'jane.doe.gmail.com' cannot be told apart from an opaque id. It travels in bodies, and in a URL only as the path segment of GET /v1/accounts/{account_id} and its /assessments. An assessment requested by a provider hook at pre_registration, which has no account yet, carries the server-issued account_id pre: followed by its assessment_id.
-        field(
-          :account_id,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id"), required: true}}
-        )
+        # This assessment's id, equal to detail.assessment_id.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
         # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
         field(
           :status,
@@ -33,210 +23,85 @@ module NoResponse
             }
           }
         )
-        # Ordinal confidence in the recommendation under the current policy: low, medium, high or unavailable.
+        # The customer event an assessment is made for: signup (a new account), login (a returning sign-in) or purchase (a payment or credit grant). The account's risk is reported with the decision for this flow.
         field(
-          :confidence,
-          Models::Shared::Confidence,
+          :flow,
+          Models::Shared::Flow,
           {
             'format_json': {
-              'letter_case': ::NoResponse::Utils.field_name("confidence"),
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
               required: true,
-              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Confidence, false)
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Flow, false)
             }
           }
         )
-        # The lanes that did not settle, each listed once with a reason; lanes, not sources. In a detailed view a lane is listed exactly when one of its signals did not settle; a standard view carries no signals to match.
+        # How long the synchronous answer waits for sources. quick waits only for the fast sources, those that answer within 500 ms of ingress (or deadline_ms when lower); full waits for the whole budget, up to 3000 ms. Sources still running at the cut continue asynchronously and update the assessment either way.
         field(
-          :incomplete_sources,
-          Crystalline::Array.new(Models::Shared::IncompleteSource),
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("incomplete_sources"), required: true}}
-        )
-        # Version of the hand-authored heuristic weights that produced the recommendation, for example 'risk-2026-10.7'. A tenant threshold override adds a +t<N> suffix, e.g. 'risk-2026-10.7+t3'.
-        field(
-          :policy_version,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_version"), required: true}}
-        )
-        # Monotonic revision of this assessment. 1 on the synchronous answer; each material change while the assessment is served (an async continuation settling a source, a change of recommendation, confidence or status) increments it. Expiry does not increment it: an expired assessment is gone, not revised, and the expiry webhook carries the last served version.
-        field(
-          :assessment_version,
-          ::Integer,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessment_version"), required: true}}
-        )
-        # When the assessment was created. Fixed for the life of the assessment: every revision carries the same created_at.
-        field(
-          :created_at,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
-        )
-
-        field(
-          :updated_at,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("updated_at"), required: true}}
-        )
-        # After this instant the assessment is no longer served: GET /v1/assessments/{assessment_id} answers 404 and it leaves the account history. It is created_at plus your retention period at creation (default and maximum 365 days) and is fixed per record: a later revision keeps it, and a new assessment for the same account starts its own clock. If you later shorten retention, the effective expiry becomes created_at plus the shorter of the two periods.
-        field(
-          :expires_at,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("expires_at"), required: true}}
-        )
-
-        field(
-          :timing,
-          Models::Shared::AssessmentTiming,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("timing"), required: true}}
-        )
-        # Version of the body shape.
-        field(
-          :schema_version,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
-        )
-        # An optional provider correlation id, echoed back. It is not an idempotency key. Refuses an exact-shape JWT or a bare 40, 64 or 128 character hex digest; a UUID is accepted.
-        field(
-          :request_id,
-          Crystalline::Nilable.new(::String),
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("request_id")}}
-        )
-        # The recommended action: allow, step_up or review. Your application applies it.
-        field(
-          :recommendation,
-          Crystalline::Nilable.new(Models::Shared::Recommendation),
+          :depth,
+          Models::Shared::Depth,
           {
             'format_json': {
-              'letter_case': ::NoResponse::Utils.field_name("recommendation"),
-              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Recommendation, true)
+              'letter_case': ::NoResponse::Utils.field_name("depth"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Depth, false)
             }
           }
         )
-        # The one risk decision for this event. score is 0 (safe) to 100 (risky): the sum of the weights of the reasons that fired, clamped to 0 to 100, from hand-set versioned weights. Every answer with a recommendation carries it, and the top-level recommendation equals risk.recommendation. It names no source or provider.
-        field(
-          :risk,
-          Crystalline::Nilable.new(Models::Shared::Risk),
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("risk")}}
-        )
-        # Detailed view only (response_mode=detailed, which needs the detailed scope): a standard answer omits signals[], and a detailed one always carries it, possibly empty. The body does not name its mode, so that rule is the serving gate's; the schema states the half it can: an answer with risk.details is a detailed view and carries signals[]. At most one signal per (type, source_id, identifier).
+        # One assessment's own facts: its score and recommendation, the signals behind them, the lanes still running and its timing. risk here is this assessment's own score; the account's current risk is the account member of the assessment. risk and recommendation are present for complete and partial; assessment_url is present for pending.
         field(
-          :signals,
-          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::Signal)),
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("signals")}}
+          :detail,
+          Models::Shared::AssessmentDetail,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("detail"), required: true}}
         )
-        # Labels the v0 policy as hand-authored and not statistically validated.
+        # Version of the body shape.
         field(
-          :policy_basis,
+          :schema_version,
           ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_basis"), required: true}}
-        )
-        # Server-relative path of the authoritative assessment, GET /v1/assessments/{assessment_id}.
-        field(
-          :assessment_url,
-          Crystalline::Nilable.new(::String),
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessment_url")}}
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
         )
-        # The identity fields of the auth context the assessment was made with, echoed for the tenant's own correlation: the request's auth_context, or the one a hosted provider hook (POST /hooks/{integration_id}) built, with transport provider_hook and its hook_point. Present exactly when the request carried an auth_context, and the same on every revision of the assessment. Values are as the request or the hook sent them; tokens, timestamps, roles and scopes are not echoed, and the echo does not change the score.
+        # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling tenant's accounts. It is the risk of the account's latest assessment that has a decision (status complete or partial), by created_at and then assessment_id, scored exactly as GET /v1/assessments/{assessment_id} scores that assessment. Its assessments are the account's history (GET /v1/accounts/{account_id}/assessments).
         field(
-          :auth_context,
-          Crystalline::Nilable.new(Models::Shared::AssessmentAuthContext),
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("auth_context")}}
+          :account,
+          Crystalline::Nilable.new(Models::Shared::Account),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account")}}
         )
 
         sig {
           params(
-            assessment_id: ::String,
-            account_id: ::String,
+            id: ::String,
             status: Models::Shared::Status,
-            confidence: Models::Shared::Confidence,
-            incomplete_sources: T::Array[Models::Shared::IncompleteSource],
-            policy_version: ::String,
-            assessment_version: ::Integer,
-            created_at: ::String,
-            updated_at: ::String,
-            expires_at: ::String,
-            timing: Models::Shared::AssessmentTiming,
+            flow: Models::Shared::Flow,
+            depth: Models::Shared::Depth,
+            detail: Models::Shared::AssessmentDetail,
             schema_version: ::String,
-            request_id: T.nilable(::String),
-            recommendation: T.nilable(Models::Shared::Recommendation),
-            risk: T.nilable(Models::Shared::Risk),
-            signals: T.nilable(T::Array[Models::Shared::Signal]),
-            policy_basis: ::String,
-            assessment_url: T.nilable(::String),
-            auth_context: T.nilable(Models::Shared::AssessmentAuthContext)
+            account: T.nilable(Models::Shared::Account)
           )
             .void
         }
-        def initialize(
-          assessment_id:,
-          account_id:,
-          status:,
-          confidence:,
-          incomplete_sources:,
-          policy_version:,
-          assessment_version:,
-          created_at:,
-          updated_at:,
-          expires_at:,
-          timing:,
-          schema_version: "1",
-          request_id: nil,
-          recommendation: nil,
-          risk: nil,
-          signals: nil,
-          policy_basis: "heuristic_unvalidated",
-          assessment_url: nil,
-          auth_context: nil
-        )
-          @assessment_id = assessment_id
-          @account_id = account_id
+        def initialize(id:, status:, flow:, depth:, detail:, schema_version: "1", account: nil)
+          @id = id
           @status = status
-          @confidence = confidence
-          @incomplete_sources = incomplete_sources
-          @policy_version = policy_version
-          @assessment_version = assessment_version
-          @created_at = created_at
-          @updated_at = updated_at
-          @expires_at = expires_at
-          @timing = timing
+          @flow = flow
+          @depth = depth
+          @detail = detail
           unless schema_version == "1"
             raise ArgumentError, "Invalid value for schema_version"
           end
 
           @schema_version = "1"
-          @request_id = request_id
-          @recommendation = recommendation
-          @risk = risk
-          @signals = signals
-          unless policy_basis == "heuristic_unvalidated"
-            raise ArgumentError, "Invalid value for policy_basis"
-          end
-
-          @policy_basis = "heuristic_unvalidated"
-          @assessment_url = assessment_url
-          @auth_context = auth_context
+          @account = account
         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
-          return false unless @account_id == other.account_id
+          return false unless @id == other.id
           return false unless @status == other.status
-          return false unless @confidence == other.confidence
-          return false unless @incomplete_sources == other.incomplete_sources
-          return false unless @policy_version == other.policy_version
-          return false unless @assessment_version == other.assessment_version
-          return false unless @created_at == other.created_at
-          return false unless @updated_at == other.updated_at
-          return false unless @expires_at == other.expires_at
-          return false unless @timing == other.timing
+          return false unless @flow == other.flow
+          return false unless @depth == other.depth
+          return false unless @detail == other.detail
           return false unless @schema_version == other.schema_version
-          return false unless @request_id == other.request_id
-          return false unless @recommendation == other.recommendation
-          return false unless @risk == other.risk
-          return false unless @signals == other.signals
-          return false unless @policy_basis == other.policy_basis
-          return false unless @assessment_url == other.assessment_url
-          return false unless @auth_context == other.auth_context
+          return false unless @account == other.account
           true
         end
       end

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

@@ -6,16 +6,10 @@ class NoResponse::Models::Shared::Assessment
 end
 
 class NoResponse::Models::Shared::Assessment
-  def assessment_id
+  def id
   end
 
-  def assessment_id=(str_)
-  end
-
-  def account_id
-  end
-
-  def account_id=(str_)
+  def id=(str_)
   end
 
   def status
@@ -24,52 +18,22 @@ class NoResponse::Models::Shared::Assessment
   def status=(str_)
   end
 
-  def confidence
-  end
-
-  def confidence=(str_)
-  end
-
-  def incomplete_sources
-  end
-
-  def incomplete_sources=(str_)
-  end
-
-  def policy_version
-  end
-
-  def policy_version=(str_)
-  end
-
-  def assessment_version
-  end
-
-  def assessment_version=(str_)
-  end
-
-  def created_at
-  end
-
-  def created_at=(str_)
-  end
-
-  def updated_at
+  def flow
   end
 
-  def updated_at=(str_)
+  def flow=(str_)
   end
 
-  def expires_at
+  def depth
   end
 
-  def expires_at=(str_)
+  def depth=(str_)
   end
 
-  def timing
+  def detail
   end
 
-  def timing=(str_)
+  def detail=(str_)
   end
 
   def schema_version
@@ -78,45 +42,9 @@ class NoResponse::Models::Shared::Assessment
   def schema_version=(str_)
   end
 
-  def request_id
-  end
-
-  def request_id=(str_)
-  end
-
-  def recommendation
-  end
-
-  def recommendation=(str_)
-  end
-
-  def risk
-  end
-
-  def risk=(str_)
-  end
-
-  def signals
-  end
-
-  def signals=(str_)
-  end
-
-  def policy_basis
-  end
-
-  def policy_basis=(str_)
-  end
-
-  def assessment_url
-  end
-
-  def assessment_url=(str_)
-  end
-
-  def auth_context
+  def account
   end
 
-  def auth_context=(str_)
+  def account=(str_)
   end
 end