noresponse 10.0.12 → 10.0.13

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

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

@@ -0,0 +1,141 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One image or video a collector read, with the post that carried it.
+      class ScreeningMedia
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field(
+          :media_type,
+          Models::Shared::MediaType,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("media_type"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::MediaType, false)
+            }
+          }
+        )
+        # Where the platform serves the image or video.
+        field(
+          :media_url,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("media_url"), required: true}}
+        )
+
+        field(
+          :profile_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("profile_id"), required: true}}
+        )
+
+        field(
+          :permalink,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("permalink"), required: true}}
+        )
+
+        field(
+          :posted_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("posted_at"), required: true}}
+        )
+
+        field :kind, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("kind"), required: true}}
+
+        field(
+          :post_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("post_id")}}
+        )
+        # The caption or alt text.
+        field(
+          :text,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("text")}}
+        )
+        # SHA-256 of the screenshot taken of a flagged item.
+        field(
+          :screenshot_sha256,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("screenshot_sha256")}}
+        )
+        # When the screenshot was taken.
+        field(
+          :captured_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("captured_at")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            media_type: Models::Shared::MediaType,
+            media_url: ::String,
+            profile_id: ::String,
+            permalink: ::String,
+            posted_at: ::String,
+            kind: ::String,
+            post_id: T.nilable(::String),
+            text: T.nilable(::String),
+            screenshot_sha256: T.nilable(::String),
+            captured_at: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          media_type:,
+          media_url:,
+          profile_id:,
+          permalink:,
+          posted_at:,
+          kind: "media",
+          post_id: nil,
+          text: nil,
+          screenshot_sha256: nil,
+          captured_at: nil
+        )
+          @id = id
+          @media_type = media_type
+          @media_url = media_url
+          @profile_id = profile_id
+          @permalink = permalink
+          @posted_at = posted_at
+          unless kind == "media"
+            raise ArgumentError, "Invalid value for kind"
+          end
+
+          @kind = "media"
+          @post_id = post_id
+          @text = text
+          @screenshot_sha256 = screenshot_sha256
+          @captured_at = captured_at
+        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 @media_type == other.media_type
+          return false unless @media_url == other.media_url
+          return false unless @profile_id == other.profile_id
+          return false unless @permalink == other.permalink
+          return false unless @posted_at == other.posted_at
+          return false unless @kind == other.kind
+          return false unless @post_id == other.post_id
+          return false unless @text == other.text
+          return false unless @screenshot_sha256 == other.screenshot_sha256
+          return false unless @captured_at == other.captured_at
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningMedia
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningMedia
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def media_type
+  end
+
+  def media_type=(str_)
+  end
+
+  def media_url
+  end
+
+  def media_url=(str_)
+  end
+
+  def profile_id
+  end
+
+  def profile_id=(str_)
+  end
+
+  def permalink
+  end
+
+  def permalink=(str_)
+  end
+
+  def posted_at
+  end
+
+  def posted_at=(str_)
+  end
+
+  def kind
+  end
+
+  def kind=(str_)
+  end
+
+  def post_id
+  end
+
+  def post_id=(str_)
+  end
+
+  def text
+  end
+
+  def text=(str_)
+  end
+
+  def screenshot_sha256
+  end
+
+  def screenshot_sha256=(str_)
+  end
+
+  def captured_at
+  end
+
+  def captured_at=(str_)
+  end
+end