noresponse 10.0.10 → 10.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d96b8580166e44806112443d1675e10b636e5c6c80d66163632042e21385c8d3
-  data.tar.gz: 65422e8912fcbec275173a0d1b9fec1c0f78851bf8504a2fb6b8f8e06bf5db65
+  metadata.gz: 5d85291717a92183c2302b31d3d0f62582b5561a73c71ad96653471708f6f320
+  data.tar.gz: 21707ffd2be377765fbb485bb748edfd1f4aade4891ca596926088ccc0f7acc9
 SHA512:
-  metadata.gz: a8db10579a56cdf898208e5ba72e7d8f0d74ac9b1622469ec9704d84d2880c02b7747fff0f10e3d09a17d3af8d037a6bf489e2d0af5d1f1d0cecfa2dc02384ea
-  data.tar.gz: 399fe22b16111ba4de9cb5cb6b4e1a942682a9f931c8e5457ccc645e02c522a3571e34133adeae86a13270caee10c3d3226b81bbde7eb2c309035f4f62993d46
+  metadata.gz: faaf0a015394cdd88127765ae24a0674c25196b492d0b45b9b161af3b970c84ebe96a78e03939e39f843ca56e3327da05f0b635dd7b37d2fe80c6dc90d88dd75
+  data.tar.gz: 926780bbb6c32c1fe083c8600d760c1e78c30f23e4bab8d5d5d694b0d95afb173f17082c8e3a8de294888462bd38468bbc38f90b098c3520513702d9ad60395e

data/lib/no_response/events.rb

@@ -3029,7 +3029,7 @@ module NoResponse
       http_headers: nil
     )
       # start_screening - Start a screening.
-      # Start a screening of new attendees and everyone on watch or escalated, with an Idempotency-Key. It finishes completed, partial or failed minutes to hours later; poll it. The test environment screens with stand-ins that find no accounts.
+      # Start a screening of new attendees and everyone on watch or escalated, with an Idempotency-Key. It finishes completed, partial or failed minutes to hours later; poll it. The answer carries estimated_spend; a screening whose estimate exceeds what the daily screening cap has left answers 409 screening_cap_exceeded. The test environment screens with stand-ins that find no accounts.
       request = Models::Operations::StartScreeningRequest.new(
         workspace_id: workspace_id,
         environment: environment,

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

@@ -0,0 +1,89 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # A reviewer recorded a decision on an attendee. The decision's note stays in the API. Sent once per recorded review; an attendee's latest review is its decision, so order by decided_at.
+      class AttendeeDecided
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The attendee's event.
+        field(
+          :event_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("event_id"), required: true}}
+        )
+        # The attendee decided on.
+        field(
+          :attendee_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendee_id"), required: true}}
+        )
+        # The recorded review.
+        field(
+          :review_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("review_id"), required: true}}
+        )
+
+        field(
+          :decision,
+          Models::Shared::AttendeeDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("decision"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AttendeeDecision, false)
+            }
+          }
+        )
+        # Who decided: the member's external user id, or the API key's label, as the attendee's decided_by.
+        field(
+          :decided_by,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("decided_by"), required: true}}
+        )
+        # When the decision was recorded; equal to the event's created_at.
+        field(
+          :decided_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("decided_at"), required: true}}
+        )
+
+        sig {
+          params(
+            event_id: ::String,
+            attendee_id: ::String,
+            review_id: ::String,
+            decision: Models::Shared::AttendeeDecision,
+            decided_by: ::String,
+            decided_at: ::String
+          )
+            .void
+        }
+        def initialize(event_id:, attendee_id:, review_id:, decision:, decided_by:, decided_at:)
+          @event_id = event_id
+          @attendee_id = attendee_id
+          @review_id = review_id
+          @decision = decision
+          @decided_by = decided_by
+          @decided_at = decided_at
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @event_id == other.event_id
+          return false unless @attendee_id == other.attendee_id
+          return false unless @review_id == other.review_id
+          return false unless @decision == other.decision
+          return false unless @decided_by == other.decided_by
+          return false unless @decided_at == other.decided_at
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AttendeeDecided
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AttendeeDecided
+  def event_id
+  end
+
+  def event_id=(str_)
+  end
+
+  def attendee_id
+  end
+
+  def attendee_id=(str_)
+  end
+
+  def review_id
+  end
+
+  def review_id=(str_)
+  end
+
+  def decision
+  end
+
+  def decision=(str_)
+  end
+
+  def decided_by
+  end
+
+  def decided_by=(str_)
+  end
+
+  def decided_at
+  end
+
+  def decided_at=(str_)
+  end
+end

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

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The attendee.decided event.
+      class AttendeeDecidedEvent
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The event id, equal to the NR-Webhook-Id header and across redeliveries and every endpoint the event fans out to.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # When the event was created. Equal across redeliveries; the signing timestamp header is per delivery.
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+        # A reviewer recorded a decision on an attendee. The decision's note stays in the API. Sent once per recorded review; an attendee's latest review is its decision, so order by decided_at.
+        field(
+          :data,
+          Models::Shared::AttendeeDecided,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("data"), required: true}}
+        )
+        # Always attendee.decided.
+        field :type, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("type"), required: true}}
+        # Present, and true, only on an event sent by POST /v1/webhooks/{endpoint_id}/test: its data is a fixed example assessment, not one of the workspace's, so a receiver acknowledges it and applies nothing. Real events have no test member.
+        field(
+          :test,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("test")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            created_at: ::String,
+            data: Models::Shared::AttendeeDecided,
+            type: ::String,
+            test: T.nilable(T::Boolean)
+          )
+            .void
+        }
+        def initialize(id:, created_at:, data:, type: "attendee.decided", test: nil)
+          @id = id
+          @created_at = created_at
+          @data = data
+          unless type == "attendee.decided"
+            raise ArgumentError, "Invalid value for type"
+          end
+
+          @type = "attendee.decided"
+          @test = test
+        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 @created_at == other.created_at
+          return false unless @data == other.data
+          return false unless @type == other.type
+          return false unless @test == other.test
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AttendeeDecidedEvent
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AttendeeDecidedEvent
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def data
+  end
+
+  def data=(str_)
+  end
+
+  def type
+  end
+
+  def type=(str_)
+  end
+
+  def test
+  end
+
+  def test=(str_)
+  end
+end

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

@@ -0,0 +1,95 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # A screening recorded a finding on an attendee. It says which attendee and how severe, not what they posted, who they are or why: GET the attendee report for the findings. Sent once per screening that flags the attendee, so a re-screen of someone on watch announces them again.
+      class AttendeeFlagged
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The attendee's event.
+        field(
+          :event_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("event_id"), required: true}}
+        )
+        # The flagged attendee.
+        field(
+          :attendee_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendee_id"), required: true}}
+        )
+        # The screening that flagged them.
+        field(
+          :screening_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("screening_id"), required: true}}
+        )
+
+        field(
+          :highest_band,
+          Models::Shared::HighestBand,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("highest_band"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::HighestBand, false)
+            }
+          }
+        )
+        # How sure the screening is that the accounts it read are the attendee's. A finding on a possible match is at most moderate, on a probable match at most high.
+        field(
+          :match_state,
+          Models::Shared::AttendeeFlaggedMatchState,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("match_state"),
+              required: true,
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::AttendeeFlaggedMatchState, false)
+            }
+          }
+        )
+        # When the screening recorded the finding; equal to the event's created_at.
+        field(
+          :flagged_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("flagged_at"), required: true}}
+        )
+
+        sig {
+          params(
+            event_id: ::String,
+            attendee_id: ::String,
+            screening_id: ::String,
+            highest_band: Models::Shared::HighestBand,
+            match_state: Models::Shared::AttendeeFlaggedMatchState,
+            flagged_at: ::String
+          )
+            .void
+        }
+        def initialize(event_id:, attendee_id:, screening_id:, highest_band:, match_state:, flagged_at:)
+          @event_id = event_id
+          @attendee_id = attendee_id
+          @screening_id = screening_id
+          @highest_band = highest_band
+          @match_state = match_state
+          @flagged_at = flagged_at
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @event_id == other.event_id
+          return false unless @attendee_id == other.attendee_id
+          return false unless @screening_id == other.screening_id
+          return false unless @highest_band == other.highest_band
+          return false unless @match_state == other.match_state
+          return false unless @flagged_at == other.flagged_at
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AttendeeFlagged
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AttendeeFlagged
+  def event_id
+  end
+
+  def event_id=(str_)
+  end
+
+  def attendee_id
+  end
+
+  def attendee_id=(str_)
+  end
+
+  def screening_id
+  end
+
+  def screening_id=(str_)
+  end
+
+  def highest_band
+  end
+
+  def highest_band=(str_)
+  end
+
+  def match_state
+  end
+
+  def match_state=(str_)
+  end
+
+  def flagged_at
+  end
+
+  def flagged_at=(str_)
+  end
+end

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

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The attendee.flagged event.
+      class AttendeeFlaggedEvent
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The event id, equal to the NR-Webhook-Id header and across redeliveries and every endpoint the event fans out to.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # When the event was created. Equal across redeliveries; the signing timestamp header is per delivery.
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+        # A screening recorded a finding on an attendee. It says which attendee and how severe, not what they posted, who they are or why: GET the attendee report for the findings. Sent once per screening that flags the attendee, so a re-screen of someone on watch announces them again.
+        field(
+          :data,
+          Models::Shared::AttendeeFlagged,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("data"), required: true}}
+        )
+        # Always attendee.flagged.
+        field :type, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("type"), required: true}}
+        # Present, and true, only on an event sent by POST /v1/webhooks/{endpoint_id}/test: its data is a fixed example assessment, not one of the workspace's, so a receiver acknowledges it and applies nothing. Real events have no test member.
+        field(
+          :test,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("test")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            created_at: ::String,
+            data: Models::Shared::AttendeeFlagged,
+            type: ::String,
+            test: T.nilable(T::Boolean)
+          )
+            .void
+        }
+        def initialize(id:, created_at:, data:, type: "attendee.flagged", test: nil)
+          @id = id
+          @created_at = created_at
+          @data = data
+          unless type == "attendee.flagged"
+            raise ArgumentError, "Invalid value for type"
+          end
+
+          @type = "attendee.flagged"
+          @test = test
+        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 @created_at == other.created_at
+          return false unless @data == other.data
+          return false unless @type == other.type
+          return false unless @test == other.test
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AttendeeFlaggedEvent
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AttendeeFlaggedEvent
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def data
+  end
+
+  def data=(str_)
+  end
+
+  def type
+  end
+
+  def type=(str_)
+  end
+
+  def test
+  end
+
+  def test=(str_)
+  end
+end

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

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # AttendeeFlaggedMatchState - How sure the screening is that the accounts it read are the attendee's. A finding on a possible match is at most moderate, on a probable match at most high.
+      class AttendeeFlaggedMatchState < T::Enum
+        enums do
+          CONFIRMED = new("confirmed")
+          PROBABLE = new("probable")
+          POSSIBLE = new("possible")
+          NONE_FOUND = new("none_found")
+          INACCESSIBLE = new("inaccessible")
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -36,6 +36,7 @@ module NoResponse
           AGGREGATE_ERASED_DATA = new("aggregate_erased_data")
           EVENT_CONFLICT = new("event_conflict")
           EVENT_LIMIT_REACHED = new("event_limit_reached")
+          SCREENING_CAP_EXCEEDED = new("screening_cap_exceeded")
           SCREENING_UNAVAILABLE = new("screening_unavailable")
         end
 

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

@@ -4,13 +4,14 @@
 module NoResponse
   module Models
     module Shared
-      # Metric - assessments: assessments admitted. webhook_deliveries: events sent to endpoints, one per event per endpoint. key_usage_events: key-usage events accepted.
+      # Metric - assessments: assessments admitted. webhook_deliveries: events sent to endpoints, one per event per endpoint. key_usage_events: key-usage events accepted. screenings: attendees a screening recorded a final result for, one per attendee per screening; a failed attendee counts nothing.
       class Metric
         include ::Crystalline::Enum
         enums do
           ASSESSMENTS = new("assessments")
           WEBHOOK_DELIVERIES = new("webhook_deliveries")
           KEY_USAGE_EVENTS = new("key_usage_events")
+          SCREENINGS = new("screenings")
         end
 
         open!

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

@@ -9,7 +9,7 @@ module NoResponse
         extend T::Sig
         include Crystalline::MetadataFields
 
-        # One environment's settings: how long its assessments are kept, and for each flow the risk thresholds that decide it and the depth a request that names none is served at, and the sources it refuses. Live and test each have their own. A flow without thresholds of its own uses account_creation's (inherits_account_creation). Every change is recorded in the audit log as settings.updated, with who made it.
+        # One environment's settings: how long its assessments are kept, and for each flow the risk thresholds that decide it and the depth a request that names none is served at, the sources it refuses, and the daily cap on screening spend. Live and test each have their own. A flow without thresholds of its own uses account_creation's (inherits_account_creation). Every change is recorded in the audit log as settings.updated, with who made it.
         field(
           :settings,
           Models::Shared::Settings,

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

@@ -100,6 +100,18 @@ module NoResponse
           ::Integer,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendees_failed"), required: true}}
         )
+        # What the screening was estimated to cost when it started, in minor units of USD (cents): its attendees at its depth and platforms. Until the screening finishes, what it has not yet spent counts against the environment's screening_daily_cap.
+        field(
+          :estimated_spend,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("estimated_spend"), required: true}}
+        )
+        # What the attendees it has screened recorded, in minor units of USD. Each counts toward the UTC day it was recorded on; a failed attendee records nothing.
+        field(
+          :spent,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("spent"), required: true}}
+        )
 
         field(
           :started_at,
@@ -134,6 +146,8 @@ module NoResponse
             attendees_done: ::Integer,
             attendees_flagged: ::Integer,
             attendees_failed: ::Integer,
+            estimated_spend: ::Integer,
+            spent: ::Integer,
             started_at: T.nilable(::String),
             finished_at: T.nilable(::String),
             error_code: T.nilable(::String)
@@ -154,6 +168,8 @@ module NoResponse
           attendees_done:,
           attendees_flagged:,
           attendees_failed:,
+          estimated_spend:,
+          spent:,
           started_at: nil,
           finished_at: nil,
           error_code: nil
@@ -171,6 +187,8 @@ module NoResponse
           @attendees_done = attendees_done
           @attendees_flagged = attendees_flagged
           @attendees_failed = attendees_failed
+          @estimated_spend = estimated_spend
+          @spent = spent
           @started_at = started_at
           @finished_at = finished_at
           @error_code = error_code
@@ -192,6 +210,8 @@ module NoResponse
           return false unless @attendees_done == other.attendees_done
           return false unless @attendees_flagged == other.attendees_flagged
           return false unless @attendees_failed == other.attendees_failed
+          return false unless @estimated_spend == other.estimated_spend
+          return false unless @spent == other.spent
           return false unless @started_at == other.started_at
           return false unless @finished_at == other.finished_at
           return false unless @error_code == other.error_code

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

@@ -84,6 +84,18 @@ class NoResponse::Models::Shared::Screening
   def attendees_failed=(str_)
   end
 
+  def estimated_spend
+  end
+
+  def estimated_spend=(str_)
+  end
+
+  def spent
+  end
+
+  def spent=(str_)
+  end
+
   def started_at
   end