noresponse 10.0.12 → 10.0.13

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

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # What a screening read on one platform.
+      class ScreeningPlatformCoverage
+        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,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("platform"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::HandlePlatform, false)
+            }
+          }
+        )
+        # covered read at least one profile; none_found looked and found no account; inaccessible found accounts that are private or locked; failed could not finish looking; unavailable has no resolver or collector enabled.
+        field(
+          :status,
+          Models::Shared::ScreeningPlatformCoverageStatus,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(
+                Models::Shared::ScreeningPlatformCoverageStatus,
+                false
+              )
+            }
+          }
+        )
+
+        field(
+          :accounts_found,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("accounts_found"), required: true}}
+        )
+
+        field(
+          :items_read,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items_read"), required: true}}
+        )
+
+        sig {
+          params(
+            platform: Models::Shared::HandlePlatform,
+            status: Models::Shared::ScreeningPlatformCoverageStatus,
+            accounts_found: ::Integer,
+            items_read: ::Integer
+          )
+            .void
+        }
+        def initialize(platform:, status:, accounts_found:, items_read:)
+          @platform = platform
+          @status = status
+          @accounts_found = accounts_found
+          @items_read = items_read
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @platform == other.platform
+          return false unless @status == other.status
+          return false unless @accounts_found == other.accounts_found
+          return false unless @items_read == other.items_read
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningPlatformCoverage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningPlatformCoverage
+  def platform
+  end
+
+  def platform=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def accounts_found
+  end
+
+  def accounts_found=(str_)
+  end
+
+  def items_read
+  end
+
+  def items_read=(str_)
+  end
+end

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

@@ -0,0 +1,22 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ScreeningPlatformCoverageStatus - covered read at least one profile; none_found looked and found no account; inaccessible found accounts that are private or locked; failed could not finish looking; unavailable has no resolver or collector enabled.
+      class ScreeningPlatformCoverageStatus
+        include ::Crystalline::Enum
+        enums do
+          COVERED = new("covered")
+          NONE_FOUND = new("none_found")
+          INACCESSIBLE = new("inaccessible")
+          FAILED = new("failed")
+          UNAVAILABLE = new("unavailable")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,111 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One post a collector read, with its permalink and time.
+      class ScreeningPost
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field :text, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("text"), 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(
+          :reply_to,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("reply_to")}}
+        )
+        # 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,
+            text: ::String,
+            profile_id: ::String,
+            permalink: ::String,
+            posted_at: ::String,
+            kind: ::String,
+            reply_to: T.nilable(::String),
+            screenshot_sha256: T.nilable(::String),
+            captured_at: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          text:,
+          profile_id:,
+          permalink:,
+          posted_at:,
+          kind: "post",
+          reply_to: nil,
+          screenshot_sha256: nil,
+          captured_at: nil
+        )
+          @id = id
+          @text = text
+          @profile_id = profile_id
+          @permalink = permalink
+          @posted_at = posted_at
+          unless kind == "post"
+            raise ArgumentError, "Invalid value for kind"
+          end
+
+          @kind = "post"
+          @reply_to = reply_to
+          @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 @text == other.text
+          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 @reply_to == other.reply_to
+          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/screeningpost.rbi

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningPost
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningPost
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def text
+  end
+
+  def text=(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 reply_to
+  end
+
+  def reply_to=(str_)
+  end
+
+  def screenshot_sha256
+  end
+
+  def screenshot_sha256=(str_)
+  end
+
+  def captured_at
+  end
+
+  def captured_at=(str_)
+  end
+end

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

@@ -0,0 +1,193 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # An account the screening matched to the attendee, how it was matched, and how much of it was read.
+      class ScreeningProfile
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # 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,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("platform"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::HandlePlatform, false)
+            }
+          }
+        )
+
+        field(
+          :handle,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("handle"), required: true}}
+        )
+
+        field :url, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("url"), required: true}}
+        # public profiles were read; a private or locked one exists but could not be read.
+        field(
+          :access,
+          Models::Shared::Access,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("access"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Access, false)
+            }
+          }
+        )
+        # How a profile was matched to the attendee: the state its evidence earns, and the evidence.
+        field(
+          :match,
+          Models::Shared::ScreeningMatch,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("match"), required: true}}
+        )
+        # The resolver, collector or analyser that produced a record, by its catalogue name.
+        field(
+          :collector,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("collector"), required: true}}
+        )
+
+        field(
+          :items_read,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items_read"), required: true}}
+        )
+
+        field(
+          :collected_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("collected_at"), required: true}}
+        )
+
+        field(
+          :display_name,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("display_name")}}
+        )
+
+        field(
+          :bio,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("bio")}}
+        )
+
+        field(
+          :avatar_url,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("avatar_url")}}
+        )
+
+        field(
+          :followers,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("followers")}}
+        )
+
+        field(
+          :account_created_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_created_at")}}
+        )
+        # The oldest item read.
+        field(
+          :period_from,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("period_from")}}
+        )
+        # The newest item read.
+        field(
+          :period_to,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("period_to")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            platform: Models::Shared::HandlePlatform,
+            handle: ::String,
+            url: ::String,
+            access: Models::Shared::Access,
+            match: Models::Shared::ScreeningMatch,
+            collector: ::String,
+            items_read: ::Integer,
+            collected_at: ::String,
+            display_name: T.nilable(::String),
+            bio: T.nilable(::String),
+            avatar_url: T.nilable(::String),
+            followers: T.nilable(::Integer),
+            account_created_at: T.nilable(::String),
+            period_from: T.nilable(::String),
+            period_to: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          platform:,
+          handle:,
+          url:,
+          access:,
+          match:,
+          collector:,
+          items_read:,
+          collected_at:,
+          display_name: nil,
+          bio: nil,
+          avatar_url: nil,
+          followers: nil,
+          account_created_at: nil,
+          period_from: nil,
+          period_to: nil
+        )
+          @id = id
+          @platform = platform
+          @handle = handle
+          @url = url
+          @access = access
+          @match = match
+          @collector = collector
+          @items_read = items_read
+          @collected_at = collected_at
+          @display_name = display_name
+          @bio = bio
+          @avatar_url = avatar_url
+          @followers = followers
+          @account_created_at = account_created_at
+          @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 @id == other.id
+          return false unless @platform == other.platform
+          return false unless @handle == other.handle
+          return false unless @url == other.url
+          return false unless @access == other.access
+          return false unless @match == other.match
+          return false unless @collector == other.collector
+          return false unless @items_read == other.items_read
+          return false unless @collected_at == other.collected_at
+          return false unless @display_name == other.display_name
+          return false unless @bio == other.bio
+          return false unless @avatar_url == other.avatar_url
+          return false unless @followers == other.followers
+          return false unless @account_created_at == other.account_created_at
+          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/screeningprofile.rbi

@@ -0,0 +1,104 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ScreeningProfile
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ScreeningProfile
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def platform
+  end
+
+  def platform=(str_)
+  end
+
+  def handle
+  end
+
+  def handle=(str_)
+  end
+
+  def url
+  end
+
+  def url=(str_)
+  end
+
+  def access
+  end
+
+  def access=(str_)
+  end
+
+  def match
+  end
+
+  def match=(str_)
+  end
+
+  def collector
+  end
+
+  def collector=(str_)
+  end
+
+  def items_read
+  end
+
+  def items_read=(str_)
+  end
+
+  def collected_at
+  end
+
+  def collected_at=(str_)
+  end
+
+  def display_name
+  end
+
+  def display_name=(str_)
+  end
+
+  def bio
+  end
+
+  def bio=(str_)
+  end
+
+  def avatar_url
+  end
+
+  def avatar_url=(str_)
+  end
+
+  def followers
+  end
+
+  def followers=(str_)
+  end
+
+  def account_created_at
+  end
+
+  def account_created_at=(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/screeningrequest.rb

@@ -23,14 +23,11 @@ module NoResponse
 
         field(
           :platforms,
-          Crystalline::Array.new(Models::Shared::ScreeningRequestPlatform),
+          Crystalline::Array.new(Models::Shared::HandlePlatform),
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("platforms"), required: true}}
         )
 
-        sig {
-          params(depth: Models::Shared::ScreeningDepth, platforms: T::Array[Models::Shared::ScreeningRequestPlatform])
-            .void
-        }
+        sig { params(depth: Models::Shared::ScreeningDepth, platforms: T::Array[Models::Shared::HandlePlatform]).void }
         def initialize(depth:, platforms:)
           @depth = depth
           @platforms = platforms

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

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # What screening cost, in US cents, in total and per implementation.
+      class ScreeningSpend
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The total, in US cents.
+        field(
+          :total_minor,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("total_minor"), required: true}}
+        )
+
+        field(
+          :by_implementation,
+          Crystalline::Array.new(Models::Shared::ScreeningSpendLine),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("by_implementation"), required: true}}
+        )
+
+        sig { params(total_minor: ::Integer, by_implementation: T::Array[Models::Shared::ScreeningSpendLine]).void }
+        def initialize(total_minor:, by_implementation:)
+          @total_minor = total_minor
+          @by_implementation = by_implementation
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @total_minor == other.total_minor
+          return false unless @by_implementation == other.by_implementation
+          true
+        end
+      end
+    end
+  end
+end

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

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