noresponse 8.2.0 → 8.3.0

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

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

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

@@ -0,0 +1,163 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Count this environment's assessments created in [from,to) by bucket, from counts kept as each assessment is first answered, not by scanning assessments. Each assessment counts once, by its first answer (the answer served when it was first answered); later revisions and late results do not count it again, and late_flips counts its later account decision changes. from and to start a bucket (an hour, a UTC day, or a week from Monday 00:00 UTC), cover at most 366 days (31 for hour buckets) and from is inside the retention period. The filters are POST /v1/assessments/search's and describe the first answer, so a cell drills down to search with the same filters, revision first and the cell's bucket as from and to. Counts hold no identifier and stay when an assessment or account is deleted or erased; they expire with retention and go with the workspace. Reasons are counted by code and impact band, not by weight. No Idempotency-Key.
+      class AssessmentAggregateRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The first bucket's start.
+        field :from, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("from"), required: true}}
+        # The end, excluded: the start of the bucket after the last.
+        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)
+            }
+          }
+        )
+        # At most two dimensions to count by, of which at most one is reason, lane, country or asn. An assessment counts once in each of its reasons and incomplete lanes, so those groups can add up to more than the bucket's count.
+        field(
+          :group_by,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::AggregateDimension)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("group_by")}}
+        )
+        # count: each bucket's count and groups. score_histogram: first answers by flow and 5-point score bucket. late_flips: changes of an assessment's account decision for its flow after its first answer, by from, to and delay.
+        field(
+          :metrics,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::AssessmentAggregateRequestMetric)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("metrics")}}
+        )
+        # 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)
+            }
+          }
+        )
+        # 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,
+          Crystalline::Nilable.new(Models::Shared::Status),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Status, 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)
+            }
+          }
+        )
+        # 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)
+            }
+          }
+        )
+        # 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.
+        field(
+          :revision,
+          Crystalline::Nilable.new(Models::Shared::AnswerRevision),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("revision"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::AnswerRevision, true)
+            }
+          }
+        )
+        # The most groups answered: the largest over the whole range, then by value. groups_truncated says when there were more.
+        field(
+          :limit,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("limit")}}
+        )
+
+        sig {
+          params(
+            from: ::String,
+            to: ::String,
+            bucket: Models::Shared::Bucket,
+            group_by: T.nilable(T::Array[Models::Shared::AggregateDimension]),
+            metrics: T.nilable(T::Array[Models::Shared::AssessmentAggregateRequestMetric]),
+            flow: T.nilable(Models::Shared::Flow),
+            status: T.nilable(Models::Shared::Status),
+            recommendation: T.nilable(Models::Shared::Recommendation),
+            decision: T.nilable(Models::Shared::Decision),
+            revision: T.nilable(Models::Shared::AnswerRevision),
+            limit: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(
+          from:,
+          to:,
+          bucket:,
+          group_by: nil,
+          metrics: nil,
+          flow: nil,
+          status: nil,
+          recommendation: nil,
+          decision: nil,
+          revision: nil,
+          limit: 20
+        )
+          @from = from
+          @to = to
+          @bucket = bucket
+          @group_by = group_by
+          @metrics = metrics
+          @flow = flow
+          @status = status
+          @recommendation = recommendation
+          @decision = decision
+          @revision = revision
+          @limit = limit
+        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 @flow == other.flow
+          return false unless @status == other.status
+          return false unless @recommendation == other.recommendation
+          return false unless @decision == other.decision
+          return false unless @revision == other.revision
+          return false unless @limit == other.limit
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentAggregateRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentAggregateRequest
+  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 flow
+  end
+
+  def flow=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def recommendation
+  end
+
+  def recommendation=(str_)
+  end
+
+  def decision
+  end
+
+  def decision=(str_)
+  end
+
+  def revision
+  end
+
+  def revision=(str_)
+  end
+
+  def limit
+  end
+
+  def limit=(str_)
+  end
+end

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

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AssessmentAggregateRequestMetric < T::Enum
+        enums do
+          COUNT = new("count")
+          SCORE_HISTOGRAM = new("score_histogram")
+          LATE_FLIPS = new("late_flips")
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -93,6 +93,12 @@ module NoResponse
           ::String,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
         )
+        # The identifiers an assessment was sent: each member of the request's identifiers object exactly as received, before the server normalised it (the email domain keeps its case, the name its Unicode form). A member the request did not send is absent. NoResponse keeps them encrypted under the workspace's own key, does not index or log them, and deletes them with the assessment: on DELETE of the assessment or its account, at its expires_at, and with the workspace.
+        field(
+          :identifiers,
+          Crystalline::Nilable.new(Models::Shared::SentIdentifiers),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("identifiers")}}
+        )
         # 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,
@@ -155,6 +161,7 @@ module NoResponse
             expires_at: ::String,
             timing: Models::Shared::AssessmentDetailTiming,
             schema_version: ::String,
+            identifiers: T.nilable(Models::Shared::SentIdentifiers),
             request_id: T.nilable(::String),
             recommendation: T.nilable(Models::Shared::Recommendation),
             risk: T.nilable(Models::Shared::Risk),
@@ -178,6 +185,7 @@ module NoResponse
           expires_at:,
           timing:,
           schema_version: "1",
+          identifiers: nil,
           request_id: nil,
           recommendation: nil,
           risk: nil,
@@ -202,6 +210,7 @@ module NoResponse
           end
 
           @schema_version = "1"
+          @identifiers = identifiers
           @request_id = request_id
           @recommendation = recommendation
           @risk = risk
@@ -230,6 +239,7 @@ module NoResponse
           return false unless @expires_at == other.expires_at
           return false unless @timing == other.timing
           return false unless @schema_version == other.schema_version
+          return false unless @identifiers == other.identifiers
           return false unless @request_id == other.request_id
           return false unless @recommendation == other.recommendation
           return false unless @risk == other.risk

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

@@ -78,6 +78,12 @@ class NoResponse::Models::Shared::AssessmentDetail
   def schema_version=(str_)
   end
 
+  def identifiers
+  end
+
+  def identifiers=(str_)
+  end
+
   def request_id
   end
 

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

@@ -68,14 +68,25 @@ module NoResponse
             }
           }
         )
-        # 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.
+        # 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.enum_from_string(Models::Shared::Decision, true)
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Decision, true)
+            }
+          }
+        )
+        # 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.
+        field(
+          :revision,
+          Crystalline::Nilable.new(Models::Shared::AnswerRevision),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("revision"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::AnswerRevision, true)
             }
           }
         )
@@ -97,6 +108,7 @@ module NoResponse
             cursor: T.nilable(::String),
             response_mode: T.nilable(Models::Shared::ResponseMode),
             decision: T.nilable(Models::Shared::Decision),
+            revision: T.nilable(Models::Shared::AnswerRevision),
             limit: T.nilable(::Integer)
           )
             .void
@@ -111,6 +123,7 @@ module NoResponse
           cursor: nil,
           response_mode: nil,
           decision: nil,
+          revision: nil,
           limit: 20
         )
           @from = from
@@ -122,6 +135,7 @@ module NoResponse
           @cursor = cursor
           @response_mode = response_mode
           @decision = decision
+          @revision = revision
           @limit = limit
         end
 
@@ -137,6 +151,7 @@ module NoResponse
           return false unless @cursor == other.cursor
           return false unless @response_mode == other.response_mode
           return false unless @decision == other.decision
+          return false unless @revision == other.revision
           return false unless @limit == other.limit
           true
         end

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

@@ -60,6 +60,12 @@ class NoResponse::Models::Shared::AssessmentSearchRequest
   def decision=(str_)
   end
 
+  def revision
+  end
+
+  def revision=(str_)
+  end
+
   def limit
   end
 

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Bucket - The period each count covers, in UTC; a week starts on Monday.
+      class Bucket
+        include ::Crystalline::Enum
+        enums do
+          HOUR = new("hour")
+          DAY = new("day")
+          WEEK = new("week")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -4,14 +4,17 @@
 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
+      # Decision - 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.
+      class Decision
+        include ::Crystalline::Enum
         enums do
           ALLOW = new("allow")
           STEP_UP = new("step_up")
           REVIEW = new("review")
           BLOCK = new("block")
         end
+
+        open!
       end
     end
   end

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

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Delay - How long after the assessment's creation the change was made.
+      class Delay
+        include ::Crystalline::Enum
+        enums do
+          UNDER_10S = new("under_10s")
+          UNDER_1M = new("under_1m")
+          UNDER_10M = new("under_10m")
+          UNDER_1H = new("under_1h")
+          UNDER_1D = new("under_1d")
+          OVER_1D = new("over_1d")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ListMatch - The action of the list entry that decided the account.
+      class ListMatch
+        include ::Crystalline::Enum
+        enums do
+          BLOCK = new("block")
+          ALLOW = new("allow")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The identifiers an assessment was sent: each member of the request's identifiers object exactly as received, before the server normalised it (the email domain keeps its case, the name its Unicode form). A member the request did not send is absent. NoResponse keeps them encrypted under the workspace's own key, does not index or log them, and deletes them with the assessment: on DELETE of the assessment or its account, at its expires_at, and with the workspace.
+      class SentIdentifiers
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # identifiers.email as the request sent it.
+        field(
+          :email,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("email")}}
+        )
+        # identifiers.username as the request sent it.
+        field(
+          :username,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("username")}}
+        )
+        # identifiers.phone as the request sent it.
+        field(
+          :phone,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("phone")}}
+        )
+        # identifiers.name as the request sent it, before NFC normalisation.
+        field(
+          :name,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("name")}}
+        )
+        # identifiers.ip as the request sent it.
+        field(
+          :ip,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("ip")}}
+        )
+
+        sig {
+          params(
+            email: T.nilable(::String),
+            username: T.nilable(::String),
+            phone: T.nilable(::String),
+            name: T.nilable(::String),
+            ip: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(email: nil, username: nil, phone: nil, name: nil, ip: nil)
+          @email = email
+          @username = username
+          @phone = phone
+          @name = name
+          @ip = ip
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @email == other.email
+          return false unless @username == other.username
+          return false unless @phone == other.phone
+          return false unless @name == other.name
+          return false unless @ip == other.ip
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::SentIdentifiers
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::SentIdentifiers
+  def email
+  end
+
+  def email=(str_)
+  end
+
+  def username
+  end
+
+  def username=(str_)
+  end
+
+  def phone
+  end
+
+  def phone=(str_)
+  end
+
+  def name
+  end
+
+  def name=(str_)
+  end
+
+  def ip
+  end
+
+  def ip=(str_)
+  end
+end