noresponse 8.2.0 → 8.3.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/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

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

@@ -0,0 +1,121 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Body of the 200 answer to POST /v1/assessments/aggregate: one entry per bucket of [from,to), empty buckets included. Counts are of first answers and stay when an assessment or account is deleted or erased; search returns only assessments still retained.
+      class AssessmentAggregate
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :from, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("from"), required: true}}
+
+        field :to, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("to"), required: true}}
+        # The period each count covers, in UTC; a week starts on Monday.
+        field(
+          :bucket,
+          Models::Shared::Bucket,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("bucket"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Bucket, false)
+            }
+          }
+        )
+
+        field(
+          :group_by,
+          Crystalline::Array.new(Models::Shared::AggregateDimension),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("group_by"), required: true}}
+        )
+
+        field(
+          :metrics,
+          Crystalline::Array.new(Models::Shared::AssessmentAggregateMetric),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("metrics"), required: true}}
+        )
+        # true when more groups had counts than limit allowed.
+        field(
+          :groups_truncated,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("groups_truncated"), required: true}}
+        )
+
+        field(
+          :buckets,
+          Crystalline::Array.new(Models::Shared::AggregateBucket),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("buckets"), required: true}}
+        )
+        # Version of the body shape.
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
+        )
+        # The calling workspace's configured retention period in days. Default 365 (12 months), which is also the maximum: a workspace may only shorten it, to at least 1 day. Each record expires from its own created_at; see assessment expires_at.
+        field(
+          :retention_days,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retention_days")}}
+        )
+
+        sig {
+          params(
+            from: ::String,
+            to: ::String,
+            bucket: Models::Shared::Bucket,
+            group_by: T::Array[Models::Shared::AggregateDimension],
+            metrics: T::Array[Models::Shared::AssessmentAggregateMetric],
+            groups_truncated: T::Boolean,
+            buckets: T::Array[Models::Shared::AggregateBucket],
+            schema_version: ::String,
+            retention_days: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(
+          from:,
+          to:,
+          bucket:,
+          group_by:,
+          metrics:,
+          groups_truncated:,
+          buckets:,
+          schema_version: "1",
+          retention_days: 365
+        )
+          @from = from
+          @to = to
+          @bucket = bucket
+          @group_by = group_by
+          @metrics = metrics
+          @groups_truncated = groups_truncated
+          @buckets = buckets
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+          @retention_days = retention_days
+        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 @bucket == other.bucket
+          return false unless @group_by == other.group_by
+          return false unless @metrics == other.metrics
+          return false unless @groups_truncated == other.groups_truncated
+          return false unless @buckets == other.buckets
+          return false unless @schema_version == other.schema_version
+          return false unless @retention_days == other.retention_days
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentAggregate
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentAggregate
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def bucket
+  end
+
+  def bucket=(str_)
+  end
+
+  def group_by
+  end
+
+  def group_by=(str_)
+  end
+
+  def metrics
+  end
+
+  def metrics=(str_)
+  end
+
+  def groups_truncated
+  end
+
+  def groups_truncated=(str_)
+  end
+
+  def buckets
+  end
+
+  def buckets=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+
+  def retention_days
+  end
+
+  def retention_days=(str_)
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AssessmentAggregateMetric
+        include ::Crystalline::Enum
+        enums do
+          COUNT = new("count")
+          SCORE_HISTOGRAM = new("score_histogram")
+          LATE_FLIPS = new("late_flips")
+        end
+
+        open!
+      end
+    end
+  end
+end