noresponse 8.4.1 → 9.1.0

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

@@ -4,7 +4,7 @@
 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.
+      # 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. Select retained_first_answers for exact facet filters and pairs over retained detail. This mode supports count, score_histogram and score_outcomes, and refuses late_flips. It has a 31-day and 100000-record work budget.
       class AssessmentAggregateRequest
         extend T::Sig
         include Crystalline::MetadataFields
@@ -25,7 +25,7 @@ module NoResponse
             }
           }
         )
-        # 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.
+        # 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. With population retained_first_answers, both dimensions can be facets; counts cover retained first answers only.
         field(
           :group_by,
           Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::AggregateDimension)),
@@ -92,6 +92,96 @@ module NoResponse
             }
           }
         )
+        # 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,
+          Crystalline::Nilable.new(Models::Shared::Population),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("population"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Population, true)
+            }
+          }
+        )
+
+        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)
+            }
+          }
+        )
+        # 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)
+            }
+          }
+        )
+        # The selected reason's served impact band. Requires reason.
+        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")}}
+        )
+        # Inclusive lower score bound. Pending answers without a score do not match.
+        field(
+          :score_min,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_min")}}
+        )
+        # Inclusive upper score bound, at least score_min when both are supplied.
+        field(
+          :score_max,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_max")}}
+        )
+        # The list action captured at the first answer. Requires revision first. Older answers without captured list state do not match, including none.
+        field(
+          :list_match,
+          Crystalline::Nilable.new(Models::Shared::ListMatch),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("list_match"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::ListMatch, true)
+            }
+          }
+        )
         # The most groups answered: the largest over the whole range, then by value. groups_truncated says when there were more.
         field(
           :limit,
@@ -111,6 +201,16 @@ module NoResponse
             recommendation: T.nilable(Models::Shared::Recommendation),
             decision: T.nilable(Models::Shared::Decision),
             revision: T.nilable(Models::Shared::AnswerRevision),
+            population: T.nilable(Models::Shared::Population),
+            band: T.nilable(Models::Shared::Band),
+            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),
+            score_min: T.nilable(::Integer),
+            score_max: T.nilable(::Integer),
+            list_match: T.nilable(Models::Shared::ListMatch),
             limit: T.nilable(::Integer)
           )
             .void
@@ -126,6 +226,16 @@ module NoResponse
           recommendation: nil,
           decision: nil,
           revision: nil,
+          population: nil,
+          band: nil,
+          reason: nil,
+          impact: nil,
+          lane: nil,
+          country: nil,
+          asn: nil,
+          score_min: nil,
+          score_max: nil,
+          list_match: nil,
           limit: 20
         )
           @from = from
@@ -138,6 +248,16 @@ module NoResponse
           @recommendation = recommendation
           @decision = decision
           @revision = revision
+          @population = population
+          @band = band
+          @reason = reason
+          @impact = impact
+          @lane = lane
+          @country = country
+          @asn = asn
+          @score_min = score_min
+          @score_max = score_max
+          @list_match = list_match
           @limit = limit
         end
 
@@ -154,6 +274,16 @@ module NoResponse
           return false unless @recommendation == other.recommendation
           return false unless @decision == other.decision
           return false unless @revision == other.revision
+          return false unless @population == other.population
+          return false unless @band == other.band
+          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
+          return false unless @score_min == other.score_min
+          return false unless @score_max == other.score_max
+          return false unless @list_match == other.list_match
           return false unless @limit == other.limit
           true
         end

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

@@ -66,6 +66,66 @@ class NoResponse::Models::Shared::AssessmentAggregateRequest
   def revision=(str_)
   end
 
+  def population
+  end
+
+  def population=(str_)
+  end
+
+  def band
+  end
+
+  def band=(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
+
+  def score_min
+  end
+
+  def score_min=(str_)
+  end
+
+  def score_max
+  end
+
+  def score_max=(str_)
+  end
+
+  def list_match
+  end
+
+  def list_match=(str_)
+  end
+
   def limit
   end
 

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

@@ -35,6 +35,12 @@ module NoResponse
           Crystalline::Boolean.new,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("deleted"), required: true}}
         )
+        # Receipt for GET /v1/erasures/{erasure_id}, when durable storage issued one.
+        field(
+          :erasure_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("erasure_id")}}
+        )
 
         sig {
           params(
@@ -42,11 +48,12 @@ module NoResponse
             account: Models::Shared::AssessmentDeletionAccount,
             deleted_at: ::String,
             schema_version: ::String,
-            deleted: T::Boolean
+            deleted: T::Boolean,
+            erasure_id: T.nilable(::String)
           )
             .void
         }
-        def initialize(id:, account:, deleted_at:, schema_version: "1", deleted: true)
+        def initialize(id:, account:, deleted_at:, schema_version: "1", deleted: true, erasure_id: nil)
           @id = id
           @account = account
           @deleted_at = deleted_at
@@ -60,6 +67,7 @@ module NoResponse
           end
 
           @deleted = true
+          @erasure_id = erasure_id
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
@@ -70,6 +78,7 @@ module NoResponse
           return false unless @deleted_at == other.deleted_at
           return false unless @schema_version == other.schema_version
           return false unless @deleted == other.deleted
+          return false unless @erasure_id == other.erasure_id
           true
         end
       end

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

@@ -35,4 +35,10 @@ class NoResponse::Models::Shared::AssessmentDeletion
 
   def deleted=(str_)
   end
+
+  def erasure_id
+  end
+
+  def erasure_id=(str_)
+  end
 end

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

@@ -91,6 +91,85 @@ module NoResponse
           }
         )
 
+        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)
+            }
+          }
+        )
+        # 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)
+            }
+          }
+        )
+        # The selected reason's served impact band. Requires reason.
+        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")}}
+        )
+        # Inclusive lower score bound. Pending answers without a score do not match.
+        field(
+          :score_min,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_min")}}
+        )
+        # Inclusive upper score bound, at least score_min when both are supplied.
+        field(
+          :score_max,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_max")}}
+        )
+        # The list action captured at the first answer. Requires revision first. Older answers without captured list state do not match, including none.
+        field(
+          :list_match,
+          Crystalline::Nilable.new(Models::Shared::ListMatch),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("list_match"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::ListMatch, true)
+            }
+          }
+        )
+
         field(
           :limit,
           Crystalline::Nilable.new(::Integer),
@@ -109,6 +188,15 @@ module NoResponse
             response_mode: T.nilable(Models::Shared::ResponseMode),
             decision: T.nilable(Models::Shared::Decision),
             revision: T.nilable(Models::Shared::AnswerRevision),
+            band: T.nilable(Models::Shared::Band),
+            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),
+            score_min: T.nilable(::Integer),
+            score_max: T.nilable(::Integer),
+            list_match: T.nilable(Models::Shared::ListMatch),
             limit: T.nilable(::Integer)
           )
             .void
@@ -124,6 +212,15 @@ module NoResponse
           response_mode: nil,
           decision: nil,
           revision: nil,
+          band: nil,
+          reason: nil,
+          impact: nil,
+          lane: nil,
+          country: nil,
+          asn: nil,
+          score_min: nil,
+          score_max: nil,
+          list_match: nil,
           limit: 20
         )
           @from = from
@@ -136,6 +233,15 @@ module NoResponse
           @response_mode = response_mode
           @decision = decision
           @revision = revision
+          @band = band
+          @reason = reason
+          @impact = impact
+          @lane = lane
+          @country = country
+          @asn = asn
+          @score_min = score_min
+          @score_max = score_max
+          @list_match = list_match
           @limit = limit
         end
 
@@ -152,6 +258,15 @@ module NoResponse
           return false unless @response_mode == other.response_mode
           return false unless @decision == other.decision
           return false unless @revision == other.revision
+          return false unless @band == other.band
+          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
+          return false unless @score_min == other.score_min
+          return false unless @score_max == other.score_max
+          return false unless @list_match == other.list_match
           return false unless @limit == other.limit
           true
         end

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

@@ -66,6 +66,60 @@ class NoResponse::Models::Shared::AssessmentSearchRequest
   def revision=(str_)
   end
 
+  def band
+  end
+
+  def band=(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
+
+  def score_min
+  end
+
+  def score_min=(str_)
+  end
+
+  def score_max
+  end
+
+  def score_max=(str_)
+  end
+
+  def list_match
+  end
+
+  def list_match=(str_)
+  end
+
   def limit
   end
 

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

@@ -0,0 +1,163 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One privileged workspace action with its actor, target, outcome and time. Successful data changes commit their audit evidence atomically. Sensitive exports record access before returning bytes. Details exclude secrets and subject identifiers.
+      class AuditEvent
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque, server-assigned event id: aud_ and a 26-character ULID.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # The workspace id, which is also its live environment's workspace id; the test environment's is the same id with :test appended. A workspace created through the API is tnt_ and a 26-character ULID.
+        field(
+          :workspace_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("workspace_id"), required: true}}
+        )
+
+        field(
+          :environment,
+          Models::Shared::AuditSettingsEnvironment,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("environment"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AuditSettingsEnvironment, false)
+            }
+          }
+        )
+        # What happened, as resource.verb: workspace.created, member.role_changed, member.removed, invite.created, invite.revoked, invite.accepted, key.rotated, webhook_endpoint.created, webhook_endpoint.deleted, webhook_endpoint.secret_rotated, integration.created, integration.deleted, integration.secret_rotated, list_entry.created, list_entry.deleted, webhook_endpoint.test_sent, webhook_endpoint.verification_requested, webhook_endpoint.delivery_replayed, assessment.created, assessment.outcome_recorded, assessment.deleted, account.outcome_recorded, account.enforcement_recorded, account.deleted, account.exported. A change with no finer name carries the permission it used, such as keys.live.write. New actions may appear; treat an unknown one as a change to its target.
+        field(
+          :action,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("action"), required: true}}
+        )
+
+        field(
+          :outcome,
+          Models::Shared::CustomerExportRequestFilterOutcome,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("outcome"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(
+                Models::Shared::CustomerExportRequestFilterOutcome,
+                false
+              )
+            }
+          }
+        )
+
+        field(
+          :actor,
+          Crystalline::DiscriminatedUnion.new(
+            "type",
+            {"user" => Models::Shared::UserActor, "api_key" => Models::Shared::KeyActor}
+          ),
+          {
+            'format_json': {'letter_case': ::NoResponse::Utils.field_name("actor"), required: true},
+            'discriminator': "type",
+            'discriminator_mapping': {"user" => Models::Shared::UserActor, "api_key" => Models::Shared::KeyActor}
+          }
+        )
+
+        field(
+          :target,
+          Models::Shared::AuditEventTarget,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("target"), required: true}}
+        )
+
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+        # At most 8 short facts about the change, keyed by lowercase names: the role a member was given or accepted (role), the invite an accepted member used (invite_id), the key that replaced a rotated one (new_key_id), the assessment a member's change acted on (assessment_id). Absent when there are none.
+        field(
+          :detail,
+          Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::String)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("detail")}}
+        )
+
+        field(
+          :affected_environment,
+          Crystalline::Nilable.new(Models::Shared::Environment),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("affected_environment"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Environment, true)
+            }
+          }
+        )
+        # Validated request correlation id, also returned in X-Request-ID, linking this event to request diagnostics. Absent on historical events without correlation.
+        field(
+          :request_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("request_id")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            workspace_id: ::String,
+            environment: Models::Shared::AuditSettingsEnvironment,
+            action: ::String,
+            outcome: Models::Shared::CustomerExportRequestFilterOutcome,
+            actor: T.any(Models::Shared::UserActor, Models::Shared::KeyActor),
+            target: Models::Shared::AuditEventTarget,
+            created_at: ::String,
+            detail: T.nilable(T::Hash[Symbol, ::String]),
+            affected_environment: T.nilable(Models::Shared::Environment),
+            request_id: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          workspace_id:,
+          environment:,
+          action:,
+          outcome:,
+          actor:,
+          target:,
+          created_at:,
+          detail: nil,
+          affected_environment: nil,
+          request_id: nil
+        )
+          @id = id
+          @workspace_id = workspace_id
+          @environment = environment
+          @action = action
+          @outcome = outcome
+          @actor = actor
+          @target = target
+          @created_at = created_at
+          @detail = detail
+          @affected_environment = affected_environment
+          @request_id = request_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @workspace_id == other.workspace_id
+          return false unless @environment == other.environment
+          return false unless @action == other.action
+          return false unless @outcome == other.outcome
+          return false unless @actor == other.actor
+          return false unless @target == other.target
+          return false unless @created_at == other.created_at
+          return false unless @detail == other.detail
+          return false unless @affected_environment == other.affected_environment
+          return false unless @request_id == other.request_id
+          true
+        end
+      end
+    end
+  end
+end