moderation_api 1.2.2 → 2.0.1

data/rbi/moderation_api/models/author_retrieve_response.rbi

@@ -0,0 +1,472 @@
+# typed: strong
+
+module ModerationAPI
+  module Models
+    class AuthorRetrieveResponse < ModerationAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModerationAPI::Models::AuthorRetrieveResponse,
+            ModerationAPI::Internal::AnyHash
+          )
+        end
+
+      # Author ID in Moderation API
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Block or suspension details, if applicable. Null if the author is enabled.
+      sig do
+        returns(T.nilable(ModerationAPI::Models::AuthorRetrieveResponse::Block))
+      end
+      attr_reader :block
+
+      sig do
+        params(
+          block:
+            T.nilable(
+              ModerationAPI::Models::AuthorRetrieveResponse::Block::OrHash
+            )
+        ).void
+      end
+      attr_writer :block
+
+      # Timestamp when author first appeared
+      sig { returns(Float) }
+      attr_accessor :first_seen
+
+      # Timestamp of last activity
+      sig { returns(Float) }
+      attr_accessor :last_seen
+
+      # Additional metadata provided by your system. We recommend including any relevant
+      # information that may assist in the moderation process.
+      sig { returns(ModerationAPI::Models::AuthorRetrieveResponse::Metadata) }
+      attr_reader :metadata
+
+      sig do
+        params(
+          metadata:
+            ModerationAPI::Models::AuthorRetrieveResponse::Metadata::OrHash
+        ).void
+      end
+      attr_writer :metadata
+
+      sig { returns(ModerationAPI::Models::AuthorRetrieveResponse::Metrics) }
+      attr_reader :metrics
+
+      sig do
+        params(
+          metrics:
+            ModerationAPI::Models::AuthorRetrieveResponse::Metrics::OrHash
+        ).void
+      end
+      attr_writer :metrics
+
+      # Risk assessment details, if available.
+      sig do
+        returns(
+          T.nilable(
+            ModerationAPI::Models::AuthorRetrieveResponse::RiskEvaluation
+          )
+        )
+      end
+      attr_reader :risk_evaluation
+
+      sig do
+        params(
+          risk_evaluation:
+            T.nilable(
+              ModerationAPI::Models::AuthorRetrieveResponse::RiskEvaluation::OrHash
+            )
+        ).void
+      end
+      attr_writer :risk_evaluation
+
+      # Current author status
+      sig do
+        returns(
+          ModerationAPI::Models::AuthorRetrieveResponse::Status::TaggedSymbol
+        )
+      end
+      attr_accessor :status
+
+      sig { returns(ModerationAPI::Models::AuthorRetrieveResponse::TrustLevel) }
+      attr_reader :trust_level
+
+      sig do
+        params(
+          trust_level:
+            ModerationAPI::Models::AuthorRetrieveResponse::TrustLevel::OrHash
+        ).void
+      end
+      attr_writer :trust_level
+
+      # Author email address
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # The author's ID from your system
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_id
+
+      # URL of the author's external profile
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_link
+
+      # Timestamp of last incident
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :last_incident
+
+      # Author name or identifier
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      # URL of the author's profile picture
+      sig { returns(T.nilable(String)) }
+      attr_accessor :profile_picture
+
+      sig do
+        params(
+          id: String,
+          block:
+            T.nilable(
+              ModerationAPI::Models::AuthorRetrieveResponse::Block::OrHash
+            ),
+          first_seen: Float,
+          last_seen: Float,
+          metadata:
+            ModerationAPI::Models::AuthorRetrieveResponse::Metadata::OrHash,
+          metrics:
+            ModerationAPI::Models::AuthorRetrieveResponse::Metrics::OrHash,
+          risk_evaluation:
+            T.nilable(
+              ModerationAPI::Models::AuthorRetrieveResponse::RiskEvaluation::OrHash
+            ),
+          status:
+            ModerationAPI::Models::AuthorRetrieveResponse::Status::OrSymbol,
+          trust_level:
+            ModerationAPI::Models::AuthorRetrieveResponse::TrustLevel::OrHash,
+          email: T.nilable(String),
+          external_id: T.nilable(String),
+          external_link: T.nilable(String),
+          last_incident: T.nilable(Float),
+          name: T.nilable(String),
+          profile_picture: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Author ID in Moderation API
+        id:,
+        # Block or suspension details, if applicable. Null if the author is enabled.
+        block:,
+        # Timestamp when author first appeared
+        first_seen:,
+        # Timestamp of last activity
+        last_seen:,
+        # Additional metadata provided by your system. We recommend including any relevant
+        # information that may assist in the moderation process.
+        metadata:,
+        metrics:,
+        # Risk assessment details, if available.
+        risk_evaluation:,
+        # Current author status
+        status:,
+        trust_level:,
+        # Author email address
+        email: nil,
+        # The author's ID from your system
+        external_id: nil,
+        # URL of the author's external profile
+        external_link: nil,
+        # Timestamp of last incident
+        last_incident: nil,
+        # Author name or identifier
+        name: nil,
+        # URL of the author's profile picture
+        profile_picture: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            block:
+              T.nilable(ModerationAPI::Models::AuthorRetrieveResponse::Block),
+            first_seen: Float,
+            last_seen: Float,
+            metadata: ModerationAPI::Models::AuthorRetrieveResponse::Metadata,
+            metrics: ModerationAPI::Models::AuthorRetrieveResponse::Metrics,
+            risk_evaluation:
+              T.nilable(
+                ModerationAPI::Models::AuthorRetrieveResponse::RiskEvaluation
+              ),
+            status:
+              ModerationAPI::Models::AuthorRetrieveResponse::Status::TaggedSymbol,
+            trust_level:
+              ModerationAPI::Models::AuthorRetrieveResponse::TrustLevel,
+            email: T.nilable(String),
+            external_id: T.nilable(String),
+            external_link: T.nilable(String),
+            last_incident: T.nilable(Float),
+            name: T.nilable(String),
+            profile_picture: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Block < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Models::AuthorRetrieveResponse::Block,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        # The moderators reason why the author was blocked or suspended.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # The timestamp until which they are blocked if the author is suspended.
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :until_
+
+        # Block or suspension details, if applicable. Null if the author is enabled.
+        sig do
+          params(reason: T.nilable(String), until_: T.nilable(Float)).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The moderators reason why the author was blocked or suspended.
+          reason: nil,
+          # The timestamp until which they are blocked if the author is suspended.
+          until_: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { reason: T.nilable(String), until_: T.nilable(Float) }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Metadata < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Models::AuthorRetrieveResponse::Metadata,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        # Whether the author's email is verified
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :email_verified
+
+        # Whether the author's identity is verified
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :identity_verified
+
+        # Whether the author is a paying customer
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :is_paying_customer
+
+        # Whether the author's phone number is verified
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :phone_verified
+
+        # Additional metadata provided by your system. We recommend including any relevant
+        # information that may assist in the moderation process.
+        sig do
+          params(
+            email_verified: T.nilable(T::Boolean),
+            identity_verified: T.nilable(T::Boolean),
+            is_paying_customer: T.nilable(T::Boolean),
+            phone_verified: T.nilable(T::Boolean)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Whether the author's email is verified
+          email_verified: nil,
+          # Whether the author's identity is verified
+          identity_verified: nil,
+          # Whether the author is a paying customer
+          is_paying_customer: nil,
+          # Whether the author's phone number is verified
+          phone_verified: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              email_verified: T.nilable(T::Boolean),
+              identity_verified: T.nilable(T::Boolean),
+              is_paying_customer: T.nilable(T::Boolean),
+              phone_verified: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Metrics < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Models::AuthorRetrieveResponse::Metrics,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        # Number of flagged content pieces
+        sig { returns(Float) }
+        attr_accessor :flagged_content
+
+        # Total pieces of content
+        sig { returns(Float) }
+        attr_accessor :total_content
+
+        # Average sentiment score of content (-1 to 1). Requires a sentiment model in your
+        # project.
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :average_sentiment
+
+        sig do
+          params(
+            flagged_content: Float,
+            total_content: Float,
+            average_sentiment: T.nilable(Float)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Number of flagged content pieces
+          flagged_content:,
+          # Total pieces of content
+          total_content:,
+          # Average sentiment score of content (-1 to 1). Requires a sentiment model in your
+          # project.
+          average_sentiment: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              flagged_content: Float,
+              total_content: Float,
+              average_sentiment: T.nilable(Float)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class RiskEvaluation < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Models::AuthorRetrieveResponse::RiskEvaluation,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        # Calculated risk level based on more than 10 behavioral signals.
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :risk_level
+
+        # Risk assessment details, if available.
+        sig { params(risk_level: T.nilable(Float)).returns(T.attached_class) }
+        def self.new(
+          # Calculated risk level based on more than 10 behavioral signals.
+          risk_level: nil
+        )
+        end
+
+        sig { override.returns({ risk_level: T.nilable(Float) }) }
+        def to_hash
+        end
+      end
+
+      # Current author status
+      module Status
+        extend ModerationAPI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, ModerationAPI::Models::AuthorRetrieveResponse::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ENABLED =
+          T.let(
+            :enabled,
+            ModerationAPI::Models::AuthorRetrieveResponse::Status::TaggedSymbol
+          )
+        SUSPENDED =
+          T.let(
+            :suspended,
+            ModerationAPI::Models::AuthorRetrieveResponse::Status::TaggedSymbol
+          )
+        BLOCKED =
+          T.let(
+            :blocked,
+            ModerationAPI::Models::AuthorRetrieveResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              ModerationAPI::Models::AuthorRetrieveResponse::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class TrustLevel < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Models::AuthorRetrieveResponse::TrustLevel,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        # Author trust level (-1, 0, 1, 2, 3, or 4)
+        sig { returns(Float) }
+        attr_accessor :level
+
+        # True if the trust level was set manually by a moderator
+        sig { returns(T::Boolean) }
+        attr_accessor :manual
+
+        sig do
+          params(level: Float, manual: T::Boolean).returns(T.attached_class)
+        end
+        def self.new(
+          # Author trust level (-1, 0, 1, 2, 3, or 4)
+          level:,
+          # True if the trust level was set manually by a moderator
+          manual:
+        )
+        end
+
+        sig { override.returns({ level: Float, manual: T::Boolean }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/moderation_api/models/author_update_params.rbi

@@ -0,0 +1,176 @@
+# typed: strong
+
+module ModerationAPI
+  module Models
+    class AuthorUpdateParams < ModerationAPI::Internal::Type::BaseModel
+      extend ModerationAPI::Internal::Type::RequestParameters::Converter
+      include ModerationAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ModerationAPI::AuthorUpdateParams,
+            ModerationAPI::Internal::AnyHash
+          )
+        end
+
+      # Author email address
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # URL of the author's external profile
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_link
+
+      # Timestamp when author first appeared
+      sig { returns(T.nilable(Float)) }
+      attr_reader :first_seen
+
+      sig { params(first_seen: Float).void }
+      attr_writer :first_seen
+
+      # Timestamp of last activity
+      sig { returns(T.nilable(Float)) }
+      attr_reader :last_seen
+
+      sig { params(last_seen: Float).void }
+      attr_writer :last_seen
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :manual_trust_level
+
+      # Additional metadata provided by your system. We recommend including any relevant
+      # information that may assist in the moderation process.
+      sig { returns(T.nilable(ModerationAPI::AuthorUpdateParams::Metadata)) }
+      attr_reader :metadata
+
+      sig do
+        params(
+          metadata: ModerationAPI::AuthorUpdateParams::Metadata::OrHash
+        ).void
+      end
+      attr_writer :metadata
+
+      # Author name or identifier
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      # URL of the author's profile picture
+      sig { returns(T.nilable(String)) }
+      attr_accessor :profile_picture
+
+      sig do
+        params(
+          email: T.nilable(String),
+          external_link: T.nilable(String),
+          first_seen: Float,
+          last_seen: Float,
+          manual_trust_level: T.nilable(Float),
+          metadata: ModerationAPI::AuthorUpdateParams::Metadata::OrHash,
+          name: T.nilable(String),
+          profile_picture: T.nilable(String),
+          request_options: ModerationAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Author email address
+        email: nil,
+        # URL of the author's external profile
+        external_link: nil,
+        # Timestamp when author first appeared
+        first_seen: nil,
+        # Timestamp of last activity
+        last_seen: nil,
+        manual_trust_level: nil,
+        # Additional metadata provided by your system. We recommend including any relevant
+        # information that may assist in the moderation process.
+        metadata: nil,
+        # Author name or identifier
+        name: nil,
+        # URL of the author's profile picture
+        profile_picture: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            email: T.nilable(String),
+            external_link: T.nilable(String),
+            first_seen: Float,
+            last_seen: Float,
+            manual_trust_level: T.nilable(Float),
+            metadata: ModerationAPI::AuthorUpdateParams::Metadata,
+            name: T.nilable(String),
+            profile_picture: T.nilable(String),
+            request_options: ModerationAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Metadata < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::AuthorUpdateParams::Metadata,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        # Whether the author's email is verified
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :email_verified
+
+        # Whether the author's identity is verified
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :identity_verified
+
+        # Whether the author is a paying customer
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :is_paying_customer
+
+        # Whether the author's phone number is verified
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :phone_verified
+
+        # Additional metadata provided by your system. We recommend including any relevant
+        # information that may assist in the moderation process.
+        sig do
+          params(
+            email_verified: T.nilable(T::Boolean),
+            identity_verified: T.nilable(T::Boolean),
+            is_paying_customer: T.nilable(T::Boolean),
+            phone_verified: T.nilable(T::Boolean)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Whether the author's email is verified
+          email_verified: nil,
+          # Whether the author's identity is verified
+          identity_verified: nil,
+          # Whether the author is a paying customer
+          is_paying_customer: nil,
+          # Whether the author's phone number is verified
+          phone_verified: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              email_verified: T.nilable(T::Boolean),
+              identity_verified: T.nilable(T::Boolean),
+              is_paying_customer: T.nilable(T::Boolean),
+              phone_verified: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end