noresponse 7.1.7 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a97a4b3919011a607db3752a122ba7eb9a565b043606a6334a53f59b2f1da769
-  data.tar.gz: 7bc76a1e03c80c265616b71450aaac189791a5cc306e6f12ad48844cd7f2e0de
+  metadata.gz: e2de9d59513cbe576c219c33c460202674d4747afe028d15854ddbf321314a26
+  data.tar.gz: 5186fdc2c70c4b31b47d2b8b1f07cb875f03a8a34d9cda04d57a08732ec29eca
 SHA512:
-  metadata.gz: e45246fd1b8c282d8b0baaeaec0e59edb70d3313c32007f80fd94170673a5168f526c149b883640af22479af0ae3917a39184ad2b56d524928b97be8cb80217d
-  data.tar.gz: b9bf9c806e2dd601ced259236ea4593458e8c2e4ccaba515e64225458c79d44c67e2daea3915a897e642f74f263c415f4a203f3619ca4033499b7f9e867356a7
+  metadata.gz: 5d3e8d53cdb965c3594da552c4935b9d311298a9d4ca0d406eac84a114b3c6d6c55584700088e5981ffcfbca514a59821e3aaddea137e9d63a007646ae25f2a6
+  data.tar.gz: 5828d43c40b7dd54d4cb35029ffec08728d9da811d8a00f9011a34d66b2a3715dd0bbe3ffcf767c457b25d11b0116a04ec371ef1296c1e43e659f6c7818f6c1f

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

@@ -27,7 +27,7 @@ module NoResponse
             }
           }
         )
-        # Every reason that fired, highest weight first. The weights sum to score before clamping.
+        # Every reason that fired: risk-raising reasons first, then neutral, then risk-lowering, each strongest impact band first and then by code. The policy's numeric weights are kept private, so a reason carries only its direction and impact band.
         field(
           :reasons,
           Crystalline::Array.new(Models::Shared::AccountRiskReason),

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-
+      # One reason that fired. direction is whether it raises or lowers the score, or is neutral (informational, it moves nothing). impact is a coarse band of how much it moves the score: none for a neutral reason, otherwise low, medium or high.
       class AccountRiskReason
         extend T::Sig
         include Crystalline::MetadataFields
@@ -23,9 +23,27 @@ module NoResponse
         )
 
         field(
-          :weight,
-          ::Integer,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("weight"), required: true}}
+          :direction,
+          Models::Shared::Direction,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("direction"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Direction, false)
+            }
+          }
+        )
+
+        field(
+          :impact,
+          Models::Shared::Impact,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("impact"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Impact, false)
+            }
+          }
         )
         # The submitted identifier or client context field a reason concerns; absent when it concerns the whole assessment. Client context is a claimed hint, not a device fingerprint.
         field(
@@ -38,27 +56,45 @@ module NoResponse
             }
           }
         )
+        # Deprecated and always 0: the policy's weights are not published. It is sent so that SDK versions that require it keep reading reasons. Read direction and impact.
+        #
+        # @deprecated true: This will be removed in a future release, please migrate away from it as soon as possible.
+        field(
+          :weight,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("weight")}}
+        )
 
         sig {
           params(
             code: Models::Shared::ReasonCode,
-            weight: ::Integer,
-            identifier: T.nilable(Models::Shared::ReasonIdentifier)
+            direction: Models::Shared::Direction,
+            impact: Models::Shared::Impact,
+            identifier: T.nilable(Models::Shared::ReasonIdentifier),
+            weight: T.nilable(::Integer)
           )
             .void
         }
-        def initialize(code:, weight:, identifier: nil)
+        def initialize(code:, direction:, impact:, identifier: nil, weight: 0)
           @code = code
-          @weight = weight
+          @direction = direction
+          @impact = impact
           @identifier = identifier
+          unless weight&.zero?
+            raise ArgumentError, "Invalid value for weight"
+          end
+
+          @weight = 0
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a?(self.class)
           return false unless @code == other.code
-          return false unless @weight == other.weight
+          return false unless @direction == other.direction
+          return false unless @impact == other.impact
           return false unless @identifier == other.identifier
+          return false unless @weight == other.weight
           true
         end
       end

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

@@ -12,10 +12,16 @@ class NoResponse::Models::Shared::AccountRiskReason
   def code=(str_)
   end
 
-  def weight
+  def direction
   end
 
-  def weight=(str_)
+  def direction=(str_)
+  end
+
+  def impact
+  end
+
+  def impact=(str_)
   end
 
   def identifier
@@ -23,4 +29,10 @@ class NoResponse::Models::Shared::AccountRiskReason
 
   def identifier=(str_)
   end
+
+  def weight
+  end
+
+  def weight=(str_)
+  end
 end

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Agreement
+        include ::Crystalline::Enum
+        enums do
+          MATCH = new("match")
+          PARTIAL = new("partial")
+          MISMATCH = new("mismatch")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -51,7 +51,7 @@ module NoResponse
           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 workspace threshold override adds a +t<N> suffix, e.g. 'risk-2026-10.7+t3'.
+        # 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,
           ::String,
@@ -110,7 +110,7 @@ module NoResponse
             }
           }
         )
-        # 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.
+        # The one risk decision for this event. score is 0 (safe) to 100 (risky), set by the reasons that fired under a hand-set, versioned heuristic policy. Each reason carries its direction and impact band; the policy's weights are not published. 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),

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

@@ -0,0 +1,54 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+      class AttributeAgreement
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :agreement,
+          Models::Shared::Agreement,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("agreement"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Agreement, false)
+            }
+          }
+        )
+
+        field(
+          :values,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("values"), required: true}}
+        )
+
+        field(
+          :support,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("support"), required: true}}
+        )
+
+        sig { params(agreement: Models::Shared::Agreement, values: ::Integer, support: ::Integer).void }
+        def initialize(agreement:, values:, support:)
+          @agreement = agreement
+          @values = values
+          @support = support
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @agreement == other.agreement
+          return false unless @values == other.values
+          return false unless @support == other.support
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AttributeAgreement
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AttributeAgreement
+  def agreement
+  end
+
+  def agreement=(str_)
+  end
+
+  def values
+  end
+
+  def values=(str_)
+  end
+
+  def support
+  end
+
+  def support=(str_)
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Direction
+        include ::Crystalline::Enum
+        enums do
+          RAISES = new("raises")
+          LOWERS = new("lowers")
+          NEUTRAL = new("neutral")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,64 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # How long and how widely the signup's email and username have existed, and how far independent sources agree on the person behind them, in years and counts only. families are the kinds of evidence that found either identifier. Omitted when nothing found them: a footprint lookup that failed makes no claim, and absence is no_digital_footprint's to state.
+      class Footprint
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :families,
+          Crystalline::Array.new(Models::Shared::FootprintFamily),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("families"), required: true}}
+        )
+        # One identifier's dated footprint across every source: the first and last year any event was seen, the years between them, the latest year a source dated activity (omitted when none did), how many distinct sites and which kinds of evidence saw it.
+        field(
+          :email,
+          Crystalline::Nilable.new(Models::Shared::FootprintTimeline),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("email")}}
+        )
+        # One identifier's dated footprint across every source: the first and last year any event was seen, the years between them, the latest year a source dated activity (omitted when none did), how many distinct sites and which kinds of evidence saw it.
+        field(
+          :username,
+          Crystalline::Nilable.new(Models::Shared::FootprintTimeline),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("username")}}
+        )
+
+        field(
+          :coherence,
+          Crystalline::Nilable.new(Models::Shared::FootprintCoherence),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("coherence")}}
+        )
+
+        sig {
+          params(
+            families: T::Array[Models::Shared::FootprintFamily],
+            email: T.nilable(Models::Shared::FootprintTimeline),
+            username: T.nilable(Models::Shared::FootprintTimeline),
+            coherence: T.nilable(Models::Shared::FootprintCoherence)
+          )
+            .void
+        }
+        def initialize(families:, email: nil, username: nil, coherence: nil)
+          @families = families
+          @email = email
+          @username = username
+          @coherence = coherence
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @families == other.families
+          return false unless @email == other.email
+          return false unless @username == other.username
+          return false unless @coherence == other.coherence
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Footprint
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Footprint
+  def families
+  end
+
+  def families=(str_)
+  end
+
+  def email
+  end
+
+  def email=(str_)
+  end
+
+  def username
+  end
+
+  def username=(str_)
+  end
+
+  def coherence
+  end
+
+  def coherence=(str_)
+  end
+end

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

@@ -0,0 +1,130 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class FootprintCoherence
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :birth_date,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("birth_date")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :gender,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("gender")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :nationality,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("nationality")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :country,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("country")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :city,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("city")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :zip,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("zip")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :name,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("name")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :company,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("company")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :website,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("website")}}
+        )
+        # How far independent sources agree on one attribute: values is the number of distinct values reported, support the tables and profiles reporting any, and agreement match (one value), partial (the most reported value holds more than half the support) or mismatch. The values themselves are not served.
+        field(
+          :social,
+          Crystalline::Nilable.new(Models::Shared::AttributeAgreement),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("social")}}
+        )
+
+        sig {
+          params(
+            birth_date: T.nilable(Models::Shared::AttributeAgreement),
+            gender: T.nilable(Models::Shared::AttributeAgreement),
+            nationality: T.nilable(Models::Shared::AttributeAgreement),
+            country: T.nilable(Models::Shared::AttributeAgreement),
+            city: T.nilable(Models::Shared::AttributeAgreement),
+            zip: T.nilable(Models::Shared::AttributeAgreement),
+            name: T.nilable(Models::Shared::AttributeAgreement),
+            company: T.nilable(Models::Shared::AttributeAgreement),
+            website: T.nilable(Models::Shared::AttributeAgreement),
+            social: T.nilable(Models::Shared::AttributeAgreement)
+          )
+            .void
+        }
+        def initialize(
+          birth_date: nil,
+          gender: nil,
+          nationality: nil,
+          country: nil,
+          city: nil,
+          zip: nil,
+          name: nil,
+          company: nil,
+          website: nil,
+          social: nil
+        )
+          @birth_date = birth_date
+          @gender = gender
+          @nationality = nationality
+          @country = country
+          @city = city
+          @zip = zip
+          @name = name
+          @company = company
+          @website = website
+          @social = social
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @birth_date == other.birth_date
+          return false unless @gender == other.gender
+          return false unless @nationality == other.nationality
+          return false unless @country == other.country
+          return false unless @city == other.city
+          return false unless @zip == other.zip
+          return false unless @name == other.name
+          return false unless @company == other.company
+          return false unless @website == other.website
+          return false unless @social == other.social
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::FootprintCoherence
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::FootprintCoherence
+  def birth_date
+  end
+
+  def birth_date=(str_)
+  end
+
+  def gender
+  end
+
+  def gender=(str_)
+  end
+
+  def nationality
+  end
+
+  def nationality=(str_)
+  end
+
+  def country
+  end
+
+  def country=(str_)
+  end
+
+  def city
+  end
+
+  def city=(str_)
+  end
+
+  def zip
+  end
+
+  def zip=(str_)
+  end
+
+  def name
+  end
+
+  def name=(str_)
+  end
+
+  def company
+  end
+
+  def company=(str_)
+  end
+
+  def website
+  end
+
+  def website=(str_)
+  end
+
+  def social
+  end
+
+  def social=(str_)
+  end
+end

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

@@ -0,0 +1,22 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # FootprintFamily - The source-neutral kind of evidence: account_presence (an account found on a site), auth_provider (the account at your auth provider), breach (breach and credential tables), breach_abuse (abuse and fraud communities' tables) and code_hosting (a code hosting profile).
+      class FootprintFamily
+        include ::Crystalline::Enum
+        enums do
+          ACCOUNT_PRESENCE = new("account_presence")
+          AUTH_PROVIDER = new("auth_provider")
+          BREACH = new("breach")
+          BREACH_ABUSE = new("breach_abuse")
+          CODE_HOSTING = new("code_hosting")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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