noresponse 10.0.11 → 10.0.13

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningCompletedByBand
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningCompletedByBand
+  def critical
+  end
+
+  def critical=(str_)
+  end
+
+  def high
+  end
+
+  def high=(str_)
+  end
+
+  def moderate
+  end
+
+  def moderate=(str_)
+  end
+
+  def low
+  end
+
+  def low=(str_)
+  end
+
+  def info
+  end
+
+  def info=(str_)
+  end
+end

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

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The screening.completed event.
+      class ScreeningCompletedEvent
+        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 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.
+        field(
+          :data,
+          Models::Shared::ScreeningCompleted,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("data"), required: true}}
+        )
+        # Always screening.completed.
+        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::ScreeningCompleted,
+            type: ::String,
+            test: T.nilable(T::Boolean)
+          )
+            .void
+        }
+        def initialize(id:, created_at:, data:, type: "screening.completed", test: nil)
+          @id = id
+          @created_at = created_at
+          @data = data
+          unless type == "screening.completed"
+            raise ArgumentError, "Invalid value for type"
+          end
+
+          @type = "screening.completed"
+          @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/screeningcompletedevent.rbi

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningCompletedEvent
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningCompletedEvent
+  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/screeningcompletedstatus.rb

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ScreeningCompletedStatus - completed reached every attendee; partial left some not fully covered (partial_coverage); failed covered nobody.
+      class ScreeningCompletedStatus < T::Enum
+        enums do
+          COMPLETED = new("completed")
+          PARTIAL = new("partial")
+          FAILED = new("failed")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningCompletedStatus
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningCompletedStatus
+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