noresponse 10.0.12 → 10.0.14

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/screeningcoverage.rb

@@ -0,0 +1,82 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The denominator of a screening: accounts found, how many could be read, items read and the period they span, so a clean result is distinct from a person nobody could see.
+      class ScreeningCoverage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :accounts_found,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("accounts_found"), required: true}}
+        )
+
+        field(
+          :accounts_accessible,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("accounts_accessible"), required: true}}
+        )
+
+        field(
+          :items_read,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items_read"), required: true}}
+        )
+
+        field(
+          :platforms,
+          Crystalline::Array.new(Models::Shared::ScreeningPlatformCoverage),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("platforms"), required: true}}
+        )
+        # The oldest item read on any platform.
+        field(
+          :period_from,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("period_from")}}
+        )
+        # The newest item read on any platform.
+        field(
+          :period_to,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("period_to")}}
+        )
+
+        sig {
+          params(
+            accounts_found: ::Integer,
+            accounts_accessible: ::Integer,
+            items_read: ::Integer,
+            platforms: T::Array[Models::Shared::ScreeningPlatformCoverage],
+            period_from: T.nilable(::String),
+            period_to: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(accounts_found:, accounts_accessible:, items_read:, platforms:, period_from: nil, period_to: nil)
+          @accounts_found = accounts_found
+          @accounts_accessible = accounts_accessible
+          @items_read = items_read
+          @platforms = platforms
+          @period_from = period_from
+          @period_to = period_to
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @accounts_found == other.accounts_found
+          return false unless @accounts_accessible == other.accounts_accessible
+          return false unless @items_read == other.items_read
+          return false unless @platforms == other.platforms
+          return false unless @period_from == other.period_from
+          return false unless @period_to == other.period_to
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningCoverage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningCoverage
+  def accounts_found
+  end
+
+  def accounts_found=(str_)
+  end
+
+  def accounts_accessible
+  end
+
+  def accounts_accessible=(str_)
+  end
+
+  def items_read
+  end
+
+  def items_read=(str_)
+  end
+
+  def platforms
+  end
+
+  def platforms=(str_)
+  end
+
+  def period_from
+  end
+
+  def period_from=(str_)
+  end
+
+  def period_to
+  end
+
+  def period_to=(str_)
+  end
+end

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

@@ -0,0 +1,152 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Something the analyser flagged. band is capped by the strongest match among the profiles of its evidence: possible at most moderate, probable at most high. capped_from is the band the analyser gave when the cap lowered it.
+      class ScreeningFinding
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # 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.
+        field(
+          :category,
+          Models::Shared::FindingCategory,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("category"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::FindingCategory, false)
+            }
+          }
+        )
+        # How severe a finding is, most severe first.
+        field(
+          :band,
+          Models::Shared::FindingBand,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("band"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::FindingBand, false)
+            }
+          }
+        )
+
+        field(
+          :confidence,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("confidence"), required: true}}
+        )
+
+        field(
+          :rationale,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("rationale"), required: true}}
+        )
+        # The posts and media that support the finding.
+        field(
+          :evidence,
+          Crystalline::Array.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("evidence"), required: true}}
+        )
+        # The resolver, collector or analyser that produced a record, by its catalogue name.
+        field(
+          :analyser,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("analyser"), required: true}}
+        )
+
+        field(
+          :model,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("model"), required: true}}
+        )
+        # What the analysis cost, in US cents.
+        field(
+          :spend_minor,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("spend_minor"), required: true}}
+        )
+
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+        # How severe a finding is, most severe first.
+        field(
+          :capped_from,
+          Crystalline::Nilable.new(Models::Shared::FindingBand),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("capped_from"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::FindingBand, true)
+            }
+          }
+        )
+
+        sig {
+          params(
+            id: ::String,
+            category: Models::Shared::FindingCategory,
+            band: Models::Shared::FindingBand,
+            confidence: ::Float,
+            rationale: ::String,
+            evidence: T::Array[::String],
+            analyser: ::String,
+            model: ::String,
+            spend_minor: ::Integer,
+            created_at: ::String,
+            capped_from: T.nilable(Models::Shared::FindingBand)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          category:,
+          band:,
+          confidence:,
+          rationale:,
+          evidence:,
+          analyser:,
+          model:,
+          spend_minor:,
+          created_at:,
+          capped_from: nil
+        )
+          @id = id
+          @category = category
+          @band = band
+          @confidence = confidence
+          @rationale = rationale
+          @evidence = evidence
+          @analyser = analyser
+          @model = model
+          @spend_minor = spend_minor
+          @created_at = created_at
+          @capped_from = capped_from
+        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 @category == other.category
+          return false unless @band == other.band
+          return false unless @confidence == other.confidence
+          return false unless @rationale == other.rationale
+          return false unless @evidence == other.evidence
+          return false unless @analyser == other.analyser
+          return false unless @model == other.model
+          return false unless @spend_minor == other.spend_minor
+          return false unless @created_at == other.created_at
+          return false unless @capped_from == other.capped_from
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningFinding
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningFinding
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def category
+  end
+
+  def category=(str_)
+  end
+
+  def band
+  end
+
+  def band=(str_)
+  end
+
+  def confidence
+  end
+
+  def confidence=(str_)
+  end
+
+  def rationale
+  end
+
+  def rationale=(str_)
+  end
+
+  def evidence
+  end
+
+  def evidence=(str_)
+  end
+
+  def analyser
+  end
+
+  def analyser=(str_)
+  end
+
+  def model
+  end
+
+  def model=(str_)
+  end
+
+  def spend_minor
+  end
+
+  def spend_minor=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def capped_from
+  end
+
+  def capped_from=(str_)
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # How a profile was matched to the attendee: the state its evidence earns, and the evidence.
+      class ScreeningMatch
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # 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.
+        field(
+          :state,
+          Models::Shared::ProfileMatchState,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("state"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ProfileMatchState, false)
+            }
+          }
+        )
+
+        field(
+          :evidence,
+          Crystalline::Array.new(Models::Shared::ScreeningMatchEvidence),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("evidence"), required: true}}
+        )
+
+        sig {
+          params(state: Models::Shared::ProfileMatchState, evidence: T::Array[Models::Shared::ScreeningMatchEvidence])
+            .void
+        }
+        def initialize(state:, evidence:)
+          @state = state
+          @evidence = evidence
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @state == other.state
+          return false unless @evidence == other.evidence
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningMatch
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningMatch
+  def state
+  end
+
+  def state=(str_)
+  end
+
+  def evidence
+  end
+
+  def evidence=(str_)
+  end
+end

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

@@ -0,0 +1,57 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One identifier that ties a profile to the attendee.
+      class ScreeningMatchEvidence
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # What matched. email, phone, supplied_handle and source_fact are hard identifiers; company, city and school are soft.
+        field(
+          :kind,
+          Models::Shared::ScreeningMatchEvidenceKind,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("kind"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ScreeningMatchEvidenceKind, false)
+            }
+          }
+        )
+        # The resolver, collector or analyser that produced a record, by its catalogue name.
+        field(
+          :resolver,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("resolver"), required: true}}
+        )
+        # Where the match was seen, such as the profile field that carried it.
+        field(
+          :detail,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("detail")}}
+        )
+
+        sig {
+          params(kind: Models::Shared::ScreeningMatchEvidenceKind, resolver: ::String, detail: T.nilable(::String)).void
+        }
+        def initialize(kind:, resolver:, detail: nil)
+          @kind = kind
+          @resolver = resolver
+          @detail = detail
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @kind == other.kind
+          return false unless @resolver == other.resolver
+          return false unless @detail == other.detail
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningMatchEvidence
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningMatchEvidence
+  def kind
+  end
+
+  def kind=(str_)
+  end
+
+  def resolver
+  end
+
+  def resolver=(str_)
+  end
+
+  def detail
+  end
+
+  def detail=(str_)
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ScreeningMatchEvidenceKind - What matched. email, phone, supplied_handle and source_fact are hard identifiers; company, city and school are soft.
+      class ScreeningMatchEvidenceKind
+        include ::Crystalline::Enum
+        enums do
+          EMAIL = new("email")
+          PHONE = new("phone")
+          SUPPLIED_HANDLE = new("supplied_handle")
+          SOURCE_FACT = new("source_fact")
+          NAME = new("name")
+          COMPANY = new("company")
+          CITY = new("city")
+          SCHOOL = new("school")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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