noresponse 8.2.1 → 8.4.0

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

@@ -0,0 +1,179 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One group's count in one bucket. It holds each grouped dimension the counted assessments had a value for: a pending first answer has no decision, recommendation or band; an answer that fired no reason, listed no incomplete lane, matched no list entry or whose IP has no known country or ASN leaves that dimension out.
+      class AggregateGroup
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :count,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("count"), required: true}}
+        )
+        # An assessment's own decision: block when its stored risk.block is true, otherwise its recommendation. It is not the account's decision or held-admission state.
+        field(
+          :decision,
+          Crystalline::Nilable.new(Models::Shared::Decision),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("decision"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Decision, 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,
+          Crystalline::Nilable.new(Models::Shared::Flow),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Flow, true)
+            }
+          }
+        )
+        # The recommended action: allow, step_up or review. Your application applies it.
+        field(
+          :recommendation,
+          Crystalline::Nilable.new(Models::Shared::Recommendation),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("recommendation"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Recommendation, true)
+            }
+          }
+        )
+        # low 0-29, medium 30-59, high 60-84, critical 85-100.
+        field(
+          :band,
+          Crystalline::Nilable.new(Models::Shared::Band),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("band"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Band, true)
+            }
+          }
+        )
+        # The action of the list entry that decided the account.
+        field(
+          :list_match,
+          Crystalline::Nilable.new(Models::Shared::ListMatch),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("list_match"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ListMatch, true)
+            }
+          }
+        )
+        # A stable reason code. New codes may appear; ignore any you do not know.
+        field(
+          :reason,
+          Crystalline::Nilable.new(Models::Shared::ReasonCode),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("reason"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ReasonCode, true)
+            }
+          }
+        )
+
+        field(
+          :impact,
+          Crystalline::Nilable.new(Models::Shared::Impact),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("impact"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Impact, true)
+            }
+          }
+        )
+        # An evidence lane: accounts (account presence for email and username), phone, breach, domain (the email domain's registration) and ip.
+        field(
+          :lane,
+          Crystalline::Nilable.new(Models::Shared::Lane),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("lane"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Lane, true)
+            }
+          }
+        )
+
+        field(
+          :country,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("country")}}
+        )
+
+        field(
+          :asn,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("asn")}}
+        )
+
+        sig {
+          params(
+            count: ::Integer,
+            decision: T.nilable(Models::Shared::Decision),
+            flow: T.nilable(Models::Shared::Flow),
+            recommendation: T.nilable(Models::Shared::Recommendation),
+            band: T.nilable(Models::Shared::Band),
+            list_match: T.nilable(Models::Shared::ListMatch),
+            reason: T.nilable(Models::Shared::ReasonCode),
+            impact: T.nilable(Models::Shared::Impact),
+            lane: T.nilable(Models::Shared::Lane),
+            country: T.nilable(::String),
+            asn: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(
+          count:,
+          decision: nil,
+          flow: nil,
+          recommendation: nil,
+          band: nil,
+          list_match: nil,
+          reason: nil,
+          impact: nil,
+          lane: nil,
+          country: nil,
+          asn: nil
+        )
+          @count = count
+          @decision = decision
+          @flow = flow
+          @recommendation = recommendation
+          @band = band
+          @list_match = list_match
+          @reason = reason
+          @impact = impact
+          @lane = lane
+          @country = country
+          @asn = asn
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @count == other.count
+          return false unless @decision == other.decision
+          return false unless @flow == other.flow
+          return false unless @recommendation == other.recommendation
+          return false unless @band == other.band
+          return false unless @list_match == other.list_match
+          return false unless @reason == other.reason
+          return false unless @impact == other.impact
+          return false unless @lane == other.lane
+          return false unless @country == other.country
+          return false unless @asn == other.asn
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AggregateGroup
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AggregateGroup
+  def count
+  end
+
+  def count=(str_)
+  end
+
+  def decision
+  end
+
+  def decision=(str_)
+  end
+
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def recommendation
+  end
+
+  def recommendation=(str_)
+  end
+
+  def band
+  end
+
+  def band=(str_)
+  end
+
+  def list_match
+  end
+
+  def list_match=(str_)
+  end
+
+  def reason
+  end
+
+  def reason=(str_)
+  end
+
+  def impact
+  end
+
+  def impact=(str_)
+  end
+
+  def lane
+  end
+
+  def lane=(str_)
+  end
+
+  def country
+  end
+
+  def country=(str_)
+  end
+
+  def asn
+  end
+
+  def asn=(str_)
+  end
+end

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

@@ -0,0 +1,83 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Changes of the account decision for an assessment's flow after its first answer, as account.risk_changed announces them, counted in the bucket of the assessment's creation. from is the decision announced before (allow before the first announcement); an assessment that changes twice counts twice.
+      class AggregateLateFlip
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. held only for a flow whose admission is held (settings flows.<flow>.admission), when the account's current assessment was made for that flow and its investigation has not completed (status partial): the final decision arrives as account.risk_changed when the investigation completes, decided by its score, or when the hold's deadline (hold_seconds after the assessment was created) passes first, as the flow's on_expiry action or the decision the evidence so far gives, whichever is stricter. Your application applies it.
+        field(
+          :from,
+          Models::Shared::AccountDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("from"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountDecision, false)
+            }
+          }
+        )
+        # block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. held only for a flow whose admission is held (settings flows.<flow>.admission), when the account's current assessment was made for that flow and its investigation has not completed (status partial): the final decision arrives as account.risk_changed when the investigation completes, decided by its score, or when the hold's deadline (hold_seconds after the assessment was created) passes first, as the flow's on_expiry action or the decision the evidence so far gives, whichever is stricter. Your application applies it.
+        field(
+          :to,
+          Models::Shared::AccountDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("to"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountDecision, false)
+            }
+          }
+        )
+        # How long after the assessment's creation the change was made.
+        field(
+          :delay,
+          Models::Shared::Delay,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("delay"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Delay, false)
+            }
+          }
+        )
+
+        field(
+          :count,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("count"), required: true}}
+        )
+
+        sig {
+          params(
+            from: Models::Shared::AccountDecision,
+            to: Models::Shared::AccountDecision,
+            delay: Models::Shared::Delay,
+            count: ::Integer
+          )
+            .void
+        }
+        def initialize(from:, to:, delay:, count:)
+          @from = from
+          @to = to
+          @delay = delay
+          @count = count
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @delay == other.delay
+          return false unless @count == other.count
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AggregateLateFlip
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AggregateLateFlip
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def delay
+  end
+
+  def delay=(str_)
+  end
+
+  def count
+  end
+
+  def count=(str_)
+  end
+end

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

@@ -0,0 +1,63 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # First answers of one flow whose risk.score is in [score_min, score_max]: 0-4, 5-9 up to 95-100. A pending answer has no score.
+      class AggregateScoreCount
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # 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)
+            }
+          }
+        )
+        # A multiple of 5.
+        field(
+          :score_min,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_min"), required: true}}
+        )
+
+        field(
+          :score_max,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_max"), required: true}}
+        )
+
+        field(
+          :count,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("count"), required: true}}
+        )
+
+        sig { params(flow: Models::Shared::Flow, score_min: ::Integer, score_max: ::Integer, count: ::Integer).void }
+        def initialize(flow:, score_min:, score_max:, count:)
+          @flow = flow
+          @score_min = score_min
+          @score_max = score_max
+          @count = count
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @flow == other.flow
+          return false unless @score_min == other.score_min
+          return false unless @score_max == other.score_max
+          return false unless @count == other.count
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AggregateScoreCount
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AggregateScoreCount
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def score_min
+  end
+
+  def score_min=(str_)
+  end
+
+  def score_max
+  end
+
+  def score_max=(str_)
+  end
+
+  def count
+  end
+
+  def count=(str_)
+  end
+end

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

@@ -0,0 +1,86 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # First answers of one flow whose risk.score is in [score_min, score_max] and whose assessment's latest reported outcome (the latest received) is outcome. Counted when the first answer is counted and moved when a later outcome wins; outcomes reported before the first answer was counted are counted with it. An outcome reported before this count existed is counted only once another outcome is reported for the assessment.
+      class AggregateScoreOutcome
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # 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)
+            }
+          }
+        )
+        # A multiple of 5.
+        field(
+          :score_min,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_min"), required: true}}
+        )
+
+        field(
+          :score_max,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_max"), 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(
+          :count,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("count"), required: true}}
+        )
+
+        sig {
+          params(
+            flow: Models::Shared::Flow,
+            score_min: ::Integer,
+            score_max: ::Integer,
+            outcome: Models::Shared::Outcome,
+            count: ::Integer
+          )
+            .void
+        }
+        def initialize(flow:, score_min:, score_max:, outcome:, count:)
+          @flow = flow
+          @score_min = score_min
+          @score_max = score_max
+          @outcome = outcome
+          @count = count
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @flow == other.flow
+          return false unless @score_min == other.score_min
+          return false unless @score_max == other.score_max
+          return false unless @outcome == other.outcome
+          return false unless @count == other.count
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AggregateScoreOutcome
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AggregateScoreOutcome
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def score_min
+  end
+
+  def score_min=(str_)
+  end
+
+  def score_max
+  end
+
+  def score_max=(str_)
+  end
+
+  def outcome
+  end
+
+  def outcome=(str_)
+  end
+
+  def count
+  end
+
+  def count=(str_)
+  end
+end

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

@@ -0,0 +1,16 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # AnswerRevision - Which answer of each assessment the filters describe: latest, the latest stored revision, or first, the first answer, as served when the assessment was first answered (POST /v1/assessments/aggregate counts first answers). A cell of an aggregate drills down to POST /v1/assessments/search with the same filters, revision first and the cell's bucket as from and to.
+      class AnswerRevision < T::Enum
+        enums do
+          LATEST = new("latest")
+          FIRST = new("first")
+        end
+      end
+    end
+  end
+end

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

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