noresponse 8.4.1 → 9.1.0

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

@@ -9,29 +9,68 @@ module NoResponse
         extend T::Sig
         include Crystalline::MetadataFields
 
+        field(
+          :type,
+          Models::Shared::AccountOutcomeActorType,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("type"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountOutcomeActorType, false)
+            }
+          }
+        )
+
         field(
           :key_id,
-          ::String,
-          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("key_id"), required: true}}
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("key_id")}}
+        )
+        # The user's id at the identity provider the console signs people in with: 1 to 256 printable ASCII characters with no space, compared exactly.
+        field(
+          :external_user_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("external_user_id")}}
         )
 
-        field :type, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("type"), required: true}}
+        field(
+          :console_credential_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("console_credential_id")}}
+        )
+        # Opaque, server-assigned member id: mem_ and a 26-character ULID. It stays the same when a removed member is invited back.
+        field(
+          :principal_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("principal_id")}}
+        )
 
-        sig { params(key_id: ::String, type: ::String).void }
-        def initialize(key_id:, type: "api_key")
+        sig {
+          params(
+            type: Models::Shared::AccountOutcomeActorType,
+            key_id: T.nilable(::String),
+            external_user_id: T.nilable(::String),
+            console_credential_id: T.nilable(::String),
+            principal_id: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(type:, key_id: nil, external_user_id: nil, console_credential_id: nil, principal_id: nil)
+          @type = type
           @key_id = key_id
-          unless type == "api_key"
-            raise ArgumentError, "Invalid value for type"
-          end
-
-          @type = "api_key"
+          @external_user_id = external_user_id
+          @console_credential_id = console_credential_id
+          @principal_id = principal_id
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a?(self.class)
-          return false unless @key_id == other.key_id
           return false unless @type == other.type
+          return false unless @key_id == other.key_id
+          return false unless @external_user_id == other.external_user_id
+          return false unless @console_credential_id == other.console_credential_id
+          return false unless @principal_id == other.principal_id
           true
         end
       end

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

@@ -6,15 +6,33 @@ class NoResponse::Models::Shared::AccountOutcomeActor
 end
 
 class NoResponse::Models::Shared::AccountOutcomeActor
+  def type
+  end
+
+  def type=(str_)
+  end
+
   def key_id
   end
 
   def key_id=(str_)
   end
 
-  def type
+  def external_user_id
   end
 
-  def type=(str_)
+  def external_user_id=(str_)
+  end
+
+  def console_credential_id
+  end
+
+  def console_credential_id=(str_)
+  end
+
+  def principal_id
+  end
+
+  def principal_id=(str_)
   end
 end

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

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AccountOutcomeActorType
+        include ::Crystalline::Enum
+        enums do
+          API_KEY = new("api_key")
+          USER = new("user")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -33,7 +33,7 @@ module NoResponse
             }
           }
         )
-
+        # The selected reason's served impact band. Requires reason.
         field(
           :impact,
           Models::Shared::Impact,

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

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Action
+        include ::Crystalline::Enum
+        enums do
+          ALLOW = new("allow")
+          BLOCK = new("block")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/{defaultdepth.rbi → action.rbi}

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

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

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Actor
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        def initialize
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -47,7 +47,7 @@ module NoResponse
             }
           }
         )
-        # low 0-29, medium 30-59, high 60-84, critical 85-100.
+
         field(
           :band,
           Crystalline::Nilable.new(Models::Shared::Band),
@@ -58,14 +58,14 @@ module NoResponse
             }
           }
         )
-        # The action of the list entry that decided the account.
+        # The list action captured with the first answer. none means no matching entry was found. For retained_first_answers an absent field means the older assessment did not capture list state; this remains a separate group.
         field(
           :list_match,
-          Crystalline::Nilable.new(Models::Shared::ListMatch),
+          Crystalline::Nilable.new(Models::Shared::AggregateGroupListMatch),
           {
             'format_json': {
               'letter_case': ::NoResponse::Utils.field_name("list_match"),
-              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ListMatch, true)
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AggregateGroupListMatch, true)
             }
           }
         )
@@ -80,7 +80,7 @@ module NoResponse
             }
           }
         )
-
+        # The selected reason's served impact band. Requires reason.
         field(
           :impact,
           Crystalline::Nilable.new(Models::Shared::Impact),
@@ -122,7 +122,7 @@ module NoResponse
             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),
+            list_match: T.nilable(Models::Shared::AggregateGroupListMatch),
             reason: T.nilable(Models::Shared::ReasonCode),
             impact: T.nilable(Models::Shared::Impact),
             lane: T.nilable(Models::Shared::Lane),

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # AggregateGroupListMatch - The list action captured with the first answer. none means no matching entry was found. For retained_first_answers an absent field means the older assessment did not capture list state; this remains a separate group.
+      class AggregateGroupListMatch
+        include ::Crystalline::Enum
+        enums do
+          BLOCK = new("block")
+          ALLOW = new("allow")
+          NONE = new("none")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -54,6 +54,12 @@ module NoResponse
           ::String,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
         )
+        # Captured in the same database snapshot as the counts. Capture start times describe when counting began, not the earliest creation time counted: an older assessment may first answer later. Older outcomes are not inferred to be absent. Erased detail cannot be returned by drill-down even while its anonymous count remains.
+        field(
+          :coverage,
+          Crystalline::Nilable.new(Models::Shared::AssessmentAggregateCoverage),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("coverage")}}
+        )
         # 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,
@@ -71,6 +77,7 @@ module NoResponse
             groups_truncated: T::Boolean,
             buckets: T::Array[Models::Shared::AggregateBucket],
             schema_version: ::String,
+            coverage: T.nilable(Models::Shared::AssessmentAggregateCoverage),
             retention_days: T.nilable(::Integer)
           )
             .void
@@ -84,6 +91,7 @@ module NoResponse
           groups_truncated:,
           buckets:,
           schema_version: "1",
+          coverage: nil,
           retention_days: 365
         )
           @from = from
@@ -98,6 +106,7 @@ module NoResponse
           end
 
           @schema_version = "1"
+          @coverage = coverage
           @retention_days = retention_days
         end
 
@@ -112,6 +121,7 @@ module NoResponse
           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 @coverage == other.coverage
           return false unless @retention_days == other.retention_days
           true
         end

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

@@ -54,6 +54,12 @@ class NoResponse::Models::Shared::AssessmentAggregate
   def schema_version=(str_)
   end
 
+  def coverage
+  end
+
+  def coverage=(str_)
+  end
+
   def retention_days
   end
 

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

@@ -0,0 +1,133 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Captured in the same database snapshot as the counts. Capture start times describe when counting began, not the earliest creation time counted: an older assessment may first answer later. Older outcomes are not inferred to be absent. Erased detail cannot be returned by drill-down even while its anonymous count remains.
+      class AssessmentAggregateCoverage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :as_of,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("as_of"), required: true}}
+        )
+
+        field(
+          :first_answers_started_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("first_answers_started_at"), required: true}}
+        )
+
+        field(
+          :score_outcomes_started_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_outcomes_started_at"), required: true}}
+        )
+
+        field(
+          :retained_from,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retained_from"), required: true}}
+        )
+        # first_answers uses anonymous counters that can include erased detail. retained_first_answers computes exact intersections over retained first answers within 31 days. Requests exceeding the 100000-record work budget are refused.
+        field(
+          :population,
+          Models::Shared::Population,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("population"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Population, false)
+            }
+          }
+        )
+
+        field(
+          :erased_records_included,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("erased_records_included"), required: true}}
+        )
+
+        field(
+          :overlapping_groups,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("overlapping_groups"), required: true}}
+        )
+
+        field(
+          :late_flip_unit,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("late_flip_unit"), required: true}}
+        )
+
+        field(
+          :historical_backfill,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("historical_backfill"), required: true}}
+        )
+
+        sig {
+          params(
+            as_of: ::String,
+            first_answers_started_at: ::String,
+            score_outcomes_started_at: ::String,
+            retained_from: ::String,
+            population: Models::Shared::Population,
+            erased_records_included: T::Boolean,
+            overlapping_groups: T::Boolean,
+            late_flip_unit: ::String,
+            historical_backfill: T::Boolean
+          )
+            .void
+        }
+        def initialize(
+          as_of:,
+          first_answers_started_at:,
+          score_outcomes_started_at:,
+          retained_from:,
+          population:,
+          erased_records_included:,
+          overlapping_groups:,
+          late_flip_unit: "decision_transitions",
+          historical_backfill: false
+        )
+          @as_of = as_of
+          @first_answers_started_at = first_answers_started_at
+          @score_outcomes_started_at = score_outcomes_started_at
+          @retained_from = retained_from
+          @population = population
+          @erased_records_included = erased_records_included
+          @overlapping_groups = overlapping_groups
+          unless late_flip_unit == "decision_transitions"
+            raise ArgumentError, "Invalid value for late_flip_unit"
+          end
+
+          @late_flip_unit = "decision_transitions"
+          unless historical_backfill == false
+            raise ArgumentError, "Invalid value for historical_backfill"
+          end
+
+          @historical_backfill = false
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @as_of == other.as_of
+          return false unless @first_answers_started_at == other.first_answers_started_at
+          return false unless @score_outcomes_started_at == other.score_outcomes_started_at
+          return false unless @retained_from == other.retained_from
+          return false unless @population == other.population
+          return false unless @erased_records_included == other.erased_records_included
+          return false unless @overlapping_groups == other.overlapping_groups
+          return false unless @late_flip_unit == other.late_flip_unit
+          return false unless @historical_backfill == other.historical_backfill
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentAggregateCoverage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentAggregateCoverage
+  def as_of
+  end
+
+  def as_of=(str_)
+  end
+
+  def first_answers_started_at
+  end
+
+  def first_answers_started_at=(str_)
+  end
+
+  def score_outcomes_started_at
+  end
+
+  def score_outcomes_started_at=(str_)
+  end
+
+  def retained_from
+  end
+
+  def retained_from=(str_)
+  end
+
+  def population
+  end
+
+  def population=(str_)
+  end
+
+  def erased_records_included
+  end
+
+  def erased_records_included=(str_)
+  end
+
+  def overlapping_groups
+  end
+
+  def overlapping_groups=(str_)
+  end
+
+  def late_flip_unit
+  end
+
+  def late_flip_unit=(str_)
+  end
+
+  def historical_backfill
+  end
+
+  def historical_backfill=(str_)
+  end
+end