noresponse 8.2.1 → 8.4.0

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,21 @@
+# 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")
+          SCORE_OUTCOMES = new("score_outcomes")
+          LATE_FLIPS = new("late_flips")
+        end
+
+        open!
+      end
+    end
+  end
+end

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. score_outcomes: the histogram's first answers that have a reported outcome, by flow, 5-point score bucket and the latest outcome reported for the assessment (POST /v1/assessments/{assessment_id}/outcomes); the rest of a bin has none reported. 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,18 @@
+# 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")
+          SCORE_OUTCOMES = new("score_outcomes")
+          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/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