noresponse 8.1.2 → 8.2.0

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::CredentialPage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::CredentialPage
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def items
+  end
+
+  def items=(str_)
+  end
+
+  def next_cursor
+  end
+
+  def next_cursor=(str_)
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Associate the SHA-256 of a high-entropy key issued by your service. Send the hash instead of the key. Repeating a hash returns its original association, including its retirement state. A hash associated with another account returns a conflict.
+      class CredentialRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("sha256"), required: true}}
+        )
+
+        sig { params(sha256: ::String).void }
+        def initialize(sha256:)
+          @sha256 = sha256
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @sha256 == other.sha256
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Decision - The decision of the assessment's latest stored revision: block when its stored risk.block is true, otherwise its recommendation. This is not the account's current decision or held-admission state. Combined with recommendation using AND.
+      class Decision < T::Enum
+        enums do
+          ALLOW = new("allow")
+          STEP_UP = new("step_up")
+          REVIEW = new("review")
+          BLOCK = new("block")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Decision
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Decision
+end

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

@@ -0,0 +1,112 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The decision prepared for one HTTP attempt. Its account field preserves the account decision returned for that attempt, even after subsequent changes.
+      class DecisionReceipt
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque, server-assigned assessment id: 'asm_' and a 26-character Crockford base32 ULID. Unique within the workspace; another workspace's assessment id answers 404.
+        field(
+          :assessment_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessment_id"), 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}}
+        )
+        # The event an assessment is made for: account_creation (a user creates an account), login (a user returns to an existing account) or purchase (a payment or a credit grant). The account's risk is reported with the decision for this flow.
+        field(
+          :flow,
+          Models::Shared::Flow,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Flow, false)
+            }
+          }
+        )
+        # 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,
+          Models::Shared::Status,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Status, false)
+            }
+          }
+        )
+        # Version of the hand-authored heuristic policy that produced the recommendation, for example 'risk-2026-10.7'. A workspace threshold override adds a +t<N> suffix, e.g. 'risk-2026-10.7+t3'.
+        field(
+          :policy_version,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_version")}}
+        )
+
+        field(
+          :score,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score")}}
+        )
+        # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling workspace'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, plus the account's own reason shared_api_key when a key issued to the account was used from many IP addresses or countries (POST /v1/key_usage/batches). Its assessments are the account's history (GET /v1/accounts/{account_id}/assessments).
+        field(
+          :account,
+          Crystalline::Nilable.new(Models::Shared::Account),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account")}}
+        )
+
+        sig {
+          params(
+            assessment_id: ::String,
+            assessment_version: ::Integer,
+            flow: Models::Shared::Flow,
+            status: Models::Shared::Status,
+            policy_version: T.nilable(::String),
+            score: T.nilable(::Integer),
+            account: T.nilable(Models::Shared::Account)
+          )
+            .void
+        }
+        def initialize(
+          assessment_id:,
+          assessment_version:,
+          flow:,
+          status:,
+          policy_version: nil,
+          score: nil,
+          account: nil
+        )
+          @assessment_id = assessment_id
+          @assessment_version = assessment_version
+          @flow = flow
+          @status = status
+          @policy_version = policy_version
+          @score = score
+          @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 @assessment_version == other.assessment_version
+          return false unless @flow == other.flow
+          return false unless @status == other.status
+          return false unless @policy_version == other.policy_version
+          return false unless @score == other.score
+          return false unless @account == other.account
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::DecisionReceipt
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::DecisionReceipt
+  def assessment_id
+  end
+
+  def assessment_id=(str_)
+  end
+
+  def assessment_version
+  end
+
+  def assessment_version=(str_)
+  end
+
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def policy_version
+  end
+
+  def policy_version=(str_)
+  end
+
+  def score
+  end
+
+  def score=(str_)
+  end
+
+  def account
+  end
+
+  def account=(str_)
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Exclusion
+        include ::Crystalline::Enum
+        enums do
+          EXPIRED_OR_ERASED_RECORDS = new("expired_or_erased_records")
+          SECRETS_AND_CREDENTIAL_DIGESTS = new("secrets_and_credential_digests")
+          PRIVATE_SOURCE_AND_WORK_PAYLOADS = new("private_source_and_work_payloads")
+          CROSS_CUSTOMER_DATA = new("cross_customer_data")
+          LEGACY_OUTCOME_NOTES = new("legacy_outcome_notes")
+          UNCAPTURED_HISTORICAL_DECISIONS = new("uncaptured_historical_decisions")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Exclusion
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Exclusion
+end

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

@@ -0,0 +1,85 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Structured fields of a retained per-assessment outcome. Legacy notes remain private as promised by the existing outcome contract.
+      class ExportAssessmentOutcome
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque, server-assigned id of one recorded outcome: 'out_' and a 26-character Crockford base32 ULID. Unique within the workspace.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # Opaque, server-assigned assessment id: 'asm_' and a 26-character Crockford base32 ULID. Unique within the workspace; another workspace's assessment id answers 404.
+        field(
+          :assessment_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessment_id"), required: true}}
+        )
+        # What the provider later learned about the assessed account. confirmed_abuse, account_takeover and chargeback report abuse; false_positive and legitimate withdraw an earlier abuse report of this workspace for the assessment; unknown is recorded only. Outcomes are append-only and the latest one recorded for an assessment wins.
+        field(
+          :outcome,
+          Models::Shared::Outcome,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("outcome"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Outcome, false)
+            }
+          }
+        )
+
+        field(
+          :observed_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("observed_at"), required: true}}
+        )
+
+        field(
+          :received_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("received_at"), required: true}}
+        )
+        # Your own opaque reference for the outcome, such as a case or ticket id. Stored as given and not interpreted; keep direct identifiers out of it.
+        field(
+          :external_ref,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("external_ref")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            assessment_id: ::String,
+            outcome: Models::Shared::Outcome,
+            observed_at: ::String,
+            received_at: ::String,
+            external_ref: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(id:, assessment_id:, outcome:, observed_at:, received_at:, external_ref: nil)
+          @id = id
+          @assessment_id = assessment_id
+          @outcome = outcome
+          @observed_at = observed_at
+          @received_at = received_at
+          @external_ref = external_ref
+        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 @assessment_id == other.assessment_id
+          return false unless @outcome == other.outcome
+          return false unless @observed_at == other.observed_at
+          return false unless @received_at == other.received_at
+          return false unless @external_ref == other.external_ref
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ExportAssessmentOutcome
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ExportAssessmentOutcome
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def assessment_id
+  end
+
+  def assessment_id=(str_)
+  end
+
+  def outcome
+  end
+
+  def outcome=(str_)
+  end
+
+  def observed_at
+  end
+
+  def observed_at=(str_)
+  end
+
+  def received_at
+  end
+
+  def received_at=(str_)
+  end
+
+  def external_ref
+  end
+
+  def external_ref=(str_)
+  end
+end

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

@@ -57,6 +57,7 @@ module NoResponse
           BREACH_SHARED_IP = new("breach_shared_ip")
           NATIONALITY_MISMATCH = new("nationality_mismatch")
           MINOR_IDENTITY = new("minor_identity")
+          REPORTED_ACCOUNT_ABUSE = new("reported_account_abuse")
         end
 
         open!

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

@@ -0,0 +1,145 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One authenticated HTTP attempt. An attempt id is independent of the caller correlation id. No raw body, path parameter, credential or source payload is retained. write_complete means the server wrote/flushed its response, not proof the client processed it. Collection is bounded best effort; ii_signup_request_diagnostic_failures_total exposes gaps. Retained for seven days or the shorter environment retention.
+      class RequestDiagnostic
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field(
+          :request_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("request_id"), required: true}}
+        )
+
+        field(
+          :route,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("route"), required: true}}
+        )
+
+        field(
+          :http_status,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("http_status"), required: true}}
+        )
+
+        field(
+          :duration_ms,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("duration_ms"), required: true}}
+        )
+
+        field(
+          :started_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("started_at"), required: true}}
+        )
+
+        field(
+          :completed_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("completed_at"), required: true}}
+        )
+
+        field(
+          :expires_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("expires_at"), required: true}}
+        )
+
+        field(
+          :idempotent_replayed,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("idempotent_replayed"), required: true}}
+        )
+
+        field(
+          :write_complete,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("write_complete"), required: true}}
+        )
+
+        field(
+          :error_code,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("error_code")}}
+        )
+        # The decision prepared for one HTTP attempt. Its account field preserves the account decision returned for that attempt, even after subsequent changes.
+        field(
+          :decision,
+          Crystalline::Nilable.new(Models::Shared::DecisionReceipt),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("decision")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            request_id: ::String,
+            route: ::String,
+            http_status: ::Integer,
+            duration_ms: ::Integer,
+            started_at: ::String,
+            completed_at: ::String,
+            expires_at: ::String,
+            idempotent_replayed: T::Boolean,
+            write_complete: T::Boolean,
+            error_code: T.nilable(::String),
+            decision: T.nilable(Models::Shared::DecisionReceipt)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          request_id:,
+          route:,
+          http_status:,
+          duration_ms:,
+          started_at:,
+          completed_at:,
+          expires_at:,
+          idempotent_replayed:,
+          write_complete:,
+          error_code: nil,
+          decision: nil
+        )
+          @id = id
+          @request_id = request_id
+          @route = route
+          @http_status = http_status
+          @duration_ms = duration_ms
+          @started_at = started_at
+          @completed_at = completed_at
+          @expires_at = expires_at
+          @idempotent_replayed = idempotent_replayed
+          @write_complete = write_complete
+          @error_code = error_code
+          @decision = decision
+        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 @request_id == other.request_id
+          return false unless @route == other.route
+          return false unless @http_status == other.http_status
+          return false unless @duration_ms == other.duration_ms
+          return false unless @started_at == other.started_at
+          return false unless @completed_at == other.completed_at
+          return false unless @expires_at == other.expires_at
+          return false unless @idempotent_replayed == other.idempotent_replayed
+          return false unless @write_complete == other.write_complete
+          return false unless @error_code == other.error_code
+          return false unless @decision == other.decision
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::RequestDiagnostic
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::RequestDiagnostic
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def request_id
+  end
+
+  def request_id=(str_)
+  end
+
+  def route
+  end
+
+  def route=(str_)
+  end
+
+  def http_status
+  end
+
+  def http_status=(str_)
+  end
+
+  def duration_ms
+  end
+
+  def duration_ms=(str_)
+  end
+
+  def started_at
+  end
+
+  def started_at=(str_)
+  end
+
+  def completed_at
+  end
+
+  def completed_at=(str_)
+  end
+
+  def expires_at
+  end
+
+  def expires_at=(str_)
+  end
+
+  def idempotent_replayed
+  end
+
+  def idempotent_replayed=(str_)
+  end
+
+  def write_complete
+  end
+
+  def write_complete=(str_)
+  end
+
+  def error_code
+  end
+
+  def error_code=(str_)
+  end
+
+  def decision
+  end
+
+  def decision=(str_)
+  end
+end