noresponse 10.0.11 → 10.0.13

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

@@ -15,18 +15,30 @@ module NoResponse
           Models::Shared::Attendee,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendee"), required: true}}
         )
-        # The accounts the screening matched, with how each was matched.
+        # The accounts the latest screening matched, with how each was matched.
         field(
           :profiles,
-          Crystalline::Array.new(Models::Shared::Profile),
+          Crystalline::Array.new(Models::Shared::ScreeningProfile),
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("profiles"), required: true}}
         )
-        # What the screening flagged, with its evidence.
+        # What the latest screening flagged, most severe first, each citing its evidence.
         field(
           :findings,
-          Crystalline::Array.new(Models::Shared::Finding),
+          Crystalline::Array.new(Models::Shared::ScreeningFinding),
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("findings"), required: true}}
         )
+        # The posts the findings cite.
+        field(
+          :posts,
+          Crystalline::Array.new(Models::Shared::ScreeningPost),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("posts"), required: true}}
+        )
+        # The images and videos the findings cite.
+        field(
+          :media,
+          Crystalline::Array.new(Models::Shared::ScreeningMedia),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("media"), required: true}}
+        )
         # Every recorded decision, oldest first.
         field(
           :reviews,
@@ -37,16 +49,20 @@ module NoResponse
         sig {
           params(
             attendee: Models::Shared::Attendee,
-            profiles: T::Array[Models::Shared::Profile],
-            findings: T::Array[Models::Shared::Finding],
+            profiles: T::Array[Models::Shared::ScreeningProfile],
+            findings: T::Array[Models::Shared::ScreeningFinding],
+            posts: T::Array[Models::Shared::ScreeningPost],
+            media: T::Array[Models::Shared::ScreeningMedia],
             reviews: T::Array[Models::Shared::AttendeeReview]
           )
             .void
         }
-        def initialize(attendee:, profiles:, findings:, reviews:)
+        def initialize(attendee:, profiles:, findings:, posts:, media:, reviews:)
           @attendee = attendee
           @profiles = profiles
           @findings = findings
+          @posts = posts
+          @media = media
           @reviews = reviews
         end
 
@@ -56,6 +72,8 @@ module NoResponse
           return false unless @attendee == other.attendee
           return false unless @profiles == other.profiles
           return false unless @findings == other.findings
+          return false unless @posts == other.posts
+          return false unless @media == other.media
           return false unless @reviews == other.reviews
           true
         end

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

@@ -24,6 +24,18 @@ class NoResponse::Models::Shared::AttendeeReport
   def findings=(str_)
   end
 
+  def posts
+  end
+
+  def posts=(str_)
+  end
+
+  def media
+  end
+
+  def media=(str_)
+  end
+
   def reviews
   end
 

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

@@ -0,0 +1,22 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # FindingBand - How severe a finding is, most severe first.
+      class FindingBand
+        include ::Crystalline::Enum
+        enums do
+          CRITICAL = new("critical")
+          HIGH = new("high")
+          MODERATE = new("moderate")
+          LOW = new("low")
+          INFO = new("info")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/{attendee_coverage.rbi → findingband.rbi}

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

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

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # FindingCategory - What a finding is about: a direct threat to the principal or the event, intent to harm without a named target, fixation on the principal, a grievance against the host, research into the venue, route or security, weapons tied to any of these, disruption or protest planning toward this event, violent extremist content or identification, prior harassment or stalking of staff or principals, or posting the principal's addresses or movements.
+      class FindingCategory
+        include ::Crystalline::Enum
+        enums do
+          DIRECT_THREAT = new("direct_threat")
+          HARM_INTENT = new("harm_intent")
+          FIXATION = new("fixation")
+          GRIEVANCE = new("grievance")
+          SECURITY_RESEARCH = new("security_research")
+          WEAPONS = new("weapons")
+          DISRUPTION = new("disruption")
+          VIOLENT_EXTREMISM = new("violent_extremism")
+          HARASSMENT = new("harassment")
+          MOVEMENT_EXPOSURE = new("movement_exposure")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/{screening_platform.rbi → findingcategory.rbi}

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

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

@@ -9,6 +9,7 @@ module NoResponse
         extend T::Sig
         include Crystalline::MetadataFields
 
+        # A platform a screening can cover. synthetic is the deterministic connector's own platform, for exercising the product end to end with no network.
         field(
           :platform,
           Models::Shared::HandlePlatform,

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-
+      # HandlePlatform - A platform a screening can cover. synthetic is the deterministic connector's own platform, for exercising the product end to end with no network.
       class HandlePlatform
         include ::Crystalline::Enum
         enums do
@@ -18,6 +18,7 @@ module NoResponse
           REDDIT = new("reddit")
           TELEGRAM = new("telegram")
           LINKEDIN = new("linkedin")
+          SYNTHETIC = new("synthetic")
         end
 
         open!

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

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class MediaType
+        include ::Crystalline::Enum
+        enums do
+          IMAGE = new("image")
+          VIDEO = new("video")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/{finding.rbi → mediatype.rbi}

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

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ProfileMatchState - How sure the screening is that a profile is the attendee's, from its evidence: confirmed is two or more hard identifiers (email, phone, a supplied handle, or a fact an existing source returned), probable is one identifier beyond the name, possible is the name alone.
+      class ProfileMatchState
+        include ::Crystalline::Enum
+        enums do
+          CONFIRMED = new("confirmed")
+          PROBABLE = new("probable")
+          POSSIBLE = new("possible")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -28,7 +28,7 @@ module NoResponse
             }
           }
         )
-        # partial finished with some attendees not covered; attendees_failed counts them.
+        # partial finished with some attendees or platforms not covered; attendees_failed and attendees_partial count them.
         field(
           :status,
           Models::Shared::ScreeningStatus,
@@ -55,7 +55,7 @@ module NoResponse
 
         field(
           :platforms,
-          Crystalline::Array.new(Models::Shared::ScreeningPlatform),
+          Crystalline::Array.new(Models::Shared::HandlePlatform),
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("platforms"), required: true}}
         )
 
@@ -100,6 +100,12 @@ module NoResponse
           ::Integer,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendees_failed"), required: true}}
         )
+        # Attendees screened with some requested platform not covered; their coverage names which.
+        field(
+          :attendees_partial,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendees_partial"), 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,
@@ -112,6 +118,12 @@ module NoResponse
           ::Integer,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("spent"), required: true}}
         )
+        # What screening cost, in US cents, in total and per implementation.
+        field(
+          :spend,
+          Models::Shared::ScreeningSpend,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("spend"), required: true}}
+        )
 
         field(
           :started_at,
@@ -138,7 +150,7 @@ module NoResponse
             environment: Models::Shared::AuditSettingsEnvironment,
             status: Models::Shared::ScreeningStatus,
             depth: Models::Shared::ScreeningDepth,
-            platforms: T::Array[Models::Shared::ScreeningPlatform],
+            platforms: T::Array[Models::Shared::HandlePlatform],
             requested_by: ::String,
             created_at: ::String,
             expires_at: ::String,
@@ -146,8 +158,10 @@ module NoResponse
             attendees_done: ::Integer,
             attendees_flagged: ::Integer,
             attendees_failed: ::Integer,
+            attendees_partial: ::Integer,
             estimated_spend: ::Integer,
             spent: ::Integer,
+            spend: Models::Shared::ScreeningSpend,
             started_at: T.nilable(::String),
             finished_at: T.nilable(::String),
             error_code: T.nilable(::String)
@@ -168,8 +182,10 @@ module NoResponse
           attendees_done:,
           attendees_flagged:,
           attendees_failed:,
+          attendees_partial:,
           estimated_spend:,
           spent:,
+          spend:,
           started_at: nil,
           finished_at: nil,
           error_code: nil
@@ -187,8 +203,10 @@ module NoResponse
           @attendees_done = attendees_done
           @attendees_flagged = attendees_flagged
           @attendees_failed = attendees_failed
+          @attendees_partial = attendees_partial
           @estimated_spend = estimated_spend
           @spent = spent
+          @spend = spend
           @started_at = started_at
           @finished_at = finished_at
           @error_code = error_code
@@ -210,8 +228,10 @@ 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 @attendees_partial == other.attendees_partial
           return false unless @estimated_spend == other.estimated_spend
           return false unless @spent == other.spent
+          return false unless @spend == other.spend
           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,12 @@ class NoResponse::Models::Shared::Screening
   def attendees_failed=(str_)
   end
 
+  def attendees_partial
+  end
+
+  def attendees_partial=(str_)
+  end
+
   def estimated_spend
   end
 
@@ -96,6 +102,12 @@ class NoResponse::Models::Shared::Screening
   def spent=(str_)
   end
 
+  def spend
+  end
+
+  def spend=(str_)
+  end
+
   def started_at
   end
 

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

@@ -0,0 +1,146 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # A screening of an event finished. It counts only the attendees this screening set out to reach, not who they are: read the roster with GET /v1/workspaces/{workspace_id}/events/{environment}/{event_id}/attendees, filtered by band, to act on them. attendees_screened + partial_coverage = attendees_total, attendees_flagged is the sum of by_band, and no_footprint counts screened attendees with no flag whose accounts were not found. A cancelled screening sends no event.
+      class ScreeningCompleted
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The screening that finished.
+        field(
+          :screening_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("screening_id"), required: true}}
+        )
+        # The event it screened.
+        field(
+          :event_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("event_id"), required: true}}
+        )
+        # completed reached every attendee; partial left some not fully covered (partial_coverage); failed covered nobody.
+        field(
+          :status,
+          Models::Shared::ScreeningCompletedStatus,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              required: true,
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::ScreeningCompletedStatus, false)
+            }
+          }
+        )
+        # Every attendee the screening set out to reach: those no screening had reached and those on watch or escalated.
+        field(
+          :attendees_total,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendees_total"), required: true}}
+        )
+        # Attendees the screening covered, flagged or not.
+        field(
+          :attendees_screened,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendees_screened"), required: true}}
+        )
+        # Screened attendees with a finding: the sum of by_band.
+        field(
+          :attendees_flagged,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attendees_flagged"), required: true}}
+        )
+        # Screened attendees by the band of their most severe finding.
+        field(
+          :by_band,
+          Models::Shared::ScreeningCompletedByBand,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("by_band"), required: true}}
+        )
+        # Screened attendees with no finding whose accounts were not found (match_state none_found). A clean result for someone with no visible accounts is not the same as a clean result for someone whose accounts were read.
+        field(
+          :no_footprint,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("no_footprint"), required: true}}
+        )
+        # Attendees the screening did not fully cover. Read each one's coverage on its attendee.
+        field(
+          :partial_coverage,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("partial_coverage"), required: true}}
+        )
+        # When the screening finished; equal to the event's created_at.
+        field(
+          :finished_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("finished_at"), required: true}}
+        )
+        # Why a partial or failed screening stopped before reaching everyone, as the screening resource says: expired, worker_attempts_exhausted, attempts_exhausted or screening_unavailable.
+        field(
+          :error_code,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("error_code")}}
+        )
+
+        sig {
+          params(
+            screening_id: ::String,
+            event_id: ::String,
+            status: Models::Shared::ScreeningCompletedStatus,
+            attendees_total: ::Integer,
+            attendees_screened: ::Integer,
+            attendees_flagged: ::Integer,
+            by_band: Models::Shared::ScreeningCompletedByBand,
+            no_footprint: ::Integer,
+            partial_coverage: ::Integer,
+            finished_at: ::String,
+            error_code: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          screening_id:,
+          event_id:,
+          status:,
+          attendees_total:,
+          attendees_screened:,
+          attendees_flagged:,
+          by_band:,
+          no_footprint:,
+          partial_coverage:,
+          finished_at:,
+          error_code: nil
+        )
+          @screening_id = screening_id
+          @event_id = event_id
+          @status = status
+          @attendees_total = attendees_total
+          @attendees_screened = attendees_screened
+          @attendees_flagged = attendees_flagged
+          @by_band = by_band
+          @no_footprint = no_footprint
+          @partial_coverage = partial_coverage
+          @finished_at = finished_at
+          @error_code = error_code
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @screening_id == other.screening_id
+          return false unless @event_id == other.event_id
+          return false unless @status == other.status
+          return false unless @attendees_total == other.attendees_total
+          return false unless @attendees_screened == other.attendees_screened
+          return false unless @attendees_flagged == other.attendees_flagged
+          return false unless @by_band == other.by_band
+          return false unless @no_footprint == other.no_footprint
+          return false unless @partial_coverage == other.partial_coverage
+          return false unless @finished_at == other.finished_at
+          return false unless @error_code == other.error_code
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningCompleted
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningCompleted
+  def screening_id
+  end
+
+  def screening_id=(str_)
+  end
+
+  def event_id
+  end
+
+  def event_id=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def attendees_total
+  end
+
+  def attendees_total=(str_)
+  end
+
+  def attendees_screened
+  end
+
+  def attendees_screened=(str_)
+  end
+
+  def attendees_flagged
+  end
+
+  def attendees_flagged=(str_)
+  end
+
+  def by_band
+  end
+
+  def by_band=(str_)
+  end
+
+  def no_footprint
+  end
+
+  def no_footprint=(str_)
+  end
+
+  def partial_coverage
+  end
+
+  def partial_coverage=(str_)
+  end
+
+  def finished_at
+  end
+
+  def finished_at=(str_)
+  end
+
+  def error_code
+  end
+
+  def error_code=(str_)
+  end
+end

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

@@ -0,0 +1,52 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Screened attendees by the band of their most severe finding.
+      class ScreeningCompletedByBand
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :critical,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("critical"), required: true}}
+        )
+
+        field :high, ::Integer, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("high"), required: true}}
+
+        field(
+          :moderate,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("moderate"), required: true}}
+        )
+
+        field :low, ::Integer, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("low"), required: true}}
+
+        field :info, ::Integer, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("info"), required: true}}
+
+        sig { params(critical: ::Integer, high: ::Integer, moderate: ::Integer, low: ::Integer, info: ::Integer).void }
+        def initialize(critical:, high:, moderate:, low:, info:)
+          @critical = critical
+          @high = high
+          @moderate = moderate
+          @low = low
+          @info = info
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @critical == other.critical
+          return false unless @high == other.high
+          return false unless @moderate == other.moderate
+          return false unless @low == other.low
+          return false unless @info == other.info
+          true
+        end
+      end
+    end
+  end
+end