moderation_api 1.2.2 → 2.0.1

data/rbi/moderation_api/models/queue/item_list_params.rbi

@@ -0,0 +1,237 @@
+# typed: strong
+
+module ModerationAPI
+  module Models
+    module Queue
+      class ItemListParams < ModerationAPI::Internal::Type::BaseModel
+        extend ModerationAPI::Internal::Type::RequestParameters::Converter
+        include ModerationAPI::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Queue::ItemListParams,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :after_date
+
+        sig { params(after_date: String).void }
+        attr_writer :after_date
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :author_id
+
+        sig { params(author_id: String).void }
+        attr_writer :author_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :before_date
+
+        sig { params(before_date: String).void }
+        attr_writer :before_date
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :conversation_ids
+
+        sig { params(conversation_ids: String).void }
+        attr_writer :conversation_ids
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :filtered_action_ids
+
+        sig { params(filtered_action_ids: String).void }
+        attr_writer :filtered_action_ids
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :include_resolved
+
+        sig { params(include_resolved: String).void }
+        attr_writer :include_resolved
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :labels
+
+        sig { params(labels: String).void }
+        attr_writer :labels
+
+        # Page number to fetch
+        sig { returns(T.nilable(Float)) }
+        attr_reader :page_number
+
+        sig { params(page_number: Float).void }
+        attr_writer :page_number
+
+        # Number of items per page
+        sig { returns(T.nilable(Float)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Float).void }
+        attr_writer :page_size
+
+        # Sort direction
+        sig do
+          returns(
+            T.nilable(
+              ModerationAPI::Queue::ItemListParams::SortDirection::OrSymbol
+            )
+          )
+        end
+        attr_reader :sort_direction
+
+        sig do
+          params(
+            sort_direction:
+              ModerationAPI::Queue::ItemListParams::SortDirection::OrSymbol
+          ).void
+        end
+        attr_writer :sort_direction
+
+        sig do
+          returns(
+            T.nilable(ModerationAPI::Queue::ItemListParams::SortField::OrSymbol)
+          )
+        end
+        attr_reader :sort_field
+
+        sig do
+          params(
+            sort_field:
+              ModerationAPI::Queue::ItemListParams::SortField::OrSymbol
+          ).void
+        end
+        attr_writer :sort_field
+
+        sig do
+          params(
+            after_date: String,
+            author_id: String,
+            before_date: String,
+            conversation_ids: String,
+            filtered_action_ids: String,
+            include_resolved: String,
+            labels: String,
+            page_number: Float,
+            page_size: Float,
+            sort_direction:
+              ModerationAPI::Queue::ItemListParams::SortDirection::OrSymbol,
+            sort_field:
+              ModerationAPI::Queue::ItemListParams::SortField::OrSymbol,
+            request_options: ModerationAPI::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          after_date: nil,
+          author_id: nil,
+          before_date: nil,
+          conversation_ids: nil,
+          filtered_action_ids: nil,
+          include_resolved: nil,
+          labels: nil,
+          # Page number to fetch
+          page_number: nil,
+          # Number of items per page
+          page_size: nil,
+          # Sort direction
+          sort_direction: nil,
+          sort_field: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              after_date: String,
+              author_id: String,
+              before_date: String,
+              conversation_ids: String,
+              filtered_action_ids: String,
+              include_resolved: String,
+              labels: String,
+              page_number: Float,
+              page_size: Float,
+              sort_direction:
+                ModerationAPI::Queue::ItemListParams::SortDirection::OrSymbol,
+              sort_field:
+                ModerationAPI::Queue::ItemListParams::SortField::OrSymbol,
+              request_options: ModerationAPI::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Sort direction
+        module SortDirection
+          extend ModerationAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, ModerationAPI::Queue::ItemListParams::SortDirection)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ASC =
+            T.let(
+              :asc,
+              ModerationAPI::Queue::ItemListParams::SortDirection::TaggedSymbol
+            )
+          DESC =
+            T.let(
+              :desc,
+              ModerationAPI::Queue::ItemListParams::SortDirection::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                ModerationAPI::Queue::ItemListParams::SortDirection::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module SortField
+          extend ModerationAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, ModerationAPI::Queue::ItemListParams::SortField)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CREATED_AT =
+            T.let(
+              :createdAt,
+              ModerationAPI::Queue::ItemListParams::SortField::TaggedSymbol
+            )
+          SEVERITY =
+            T.let(
+              :severity,
+              ModerationAPI::Queue::ItemListParams::SortField::TaggedSymbol
+            )
+          REVIEWED_AT =
+            T.let(
+              :reviewedAt,
+              ModerationAPI::Queue::ItemListParams::SortField::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                ModerationAPI::Queue::ItemListParams::SortField::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/moderation_api/models/queue/item_list_response.rbi

@@ -0,0 +1,440 @@
+# typed: strong
+
+module ModerationAPI
+  module Models
+    module Queue
+      class ItemListResponse < ModerationAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ModerationAPI::Models::Queue::ItemListResponse,
+              ModerationAPI::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T::Array[ModerationAPI::Models::Queue::ItemListResponse::Item]
+          )
+        end
+        attr_accessor :items
+
+        sig do
+          returns(ModerationAPI::Models::Queue::ItemListResponse::Pagination)
+        end
+        attr_reader :pagination
+
+        sig do
+          params(
+            pagination:
+              ModerationAPI::Models::Queue::ItemListResponse::Pagination::OrHash
+          ).void
+        end
+        attr_writer :pagination
+
+        sig do
+          params(
+            items:
+              T::Array[
+                ModerationAPI::Models::Queue::ItemListResponse::Item::OrHash
+              ],
+            pagination:
+              ModerationAPI::Models::Queue::ItemListResponse::Pagination::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(items:, pagination:)
+        end
+
+        sig do
+          override.returns(
+            {
+              items:
+                T::Array[ModerationAPI::Models::Queue::ItemListResponse::Item],
+              pagination:
+                ModerationAPI::Models::Queue::ItemListResponse::Pagination
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Item < ModerationAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ModerationAPI::Models::Queue::ItemListResponse::Item,
+                ModerationAPI::Internal::AnyHash
+              )
+            end
+
+          # Content ID
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The content to be moderated
+          sig { returns(String) }
+          attr_accessor :content
+
+          # Whether the item is flagged by any label
+          sig { returns(T::Boolean) }
+          attr_accessor :flagged
+
+          sig do
+            returns(
+              T::Array[
+                ModerationAPI::Models::Queue::ItemListResponse::Item::Label
+              ]
+            )
+          end
+          attr_accessor :labels
+
+          # Status of the item
+          sig do
+            returns(
+              ModerationAPI::Models::Queue::ItemListResponse::Item::Status::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          # Unix timestamp of when the item was created
+          sig { returns(Float) }
+          attr_accessor :timestamp
+
+          # Action IDs taken on this item
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Action
+                ]
+              )
+            )
+          end
+          attr_reader :actions
+
+          sig do
+            params(
+              actions:
+                T::Array[
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Action::OrHash
+                ]
+            ).void
+          end
+          attr_writer :actions
+
+          # Author ID
+          sig { returns(T.nilable(String)) }
+          attr_reader :author_id
+
+          sig { params(author_id: String).void }
+          attr_writer :author_id
+
+          # Type of the content object
+          sig { returns(T.nilable(String)) }
+          attr_reader :content_type
+
+          sig { params(content_type: String).void }
+          attr_writer :content_type
+
+          # Conversation ID
+          sig { returns(T.nilable(String)) }
+          attr_reader :conversation_id
+
+          sig { params(conversation_id: String).void }
+          attr_writer :conversation_id
+
+          # Content language
+          sig { returns(T.nilable(String)) }
+          attr_reader :language
+
+          sig { params(language: String).void }
+          attr_writer :language
+
+          sig do
+            params(
+              id: String,
+              content: String,
+              flagged: T::Boolean,
+              labels:
+                T::Array[
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Label::OrHash
+                ],
+              status:
+                ModerationAPI::Models::Queue::ItemListResponse::Item::Status::OrSymbol,
+              timestamp: Float,
+              actions:
+                T::Array[
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Action::OrHash
+                ],
+              author_id: String,
+              content_type: String,
+              conversation_id: String,
+              language: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Content ID
+            id:,
+            # The content to be moderated
+            content:,
+            # Whether the item is flagged by any label
+            flagged:,
+            labels:,
+            # Status of the item
+            status:,
+            # Unix timestamp of when the item was created
+            timestamp:,
+            # Action IDs taken on this item
+            actions: nil,
+            # Author ID
+            author_id: nil,
+            # Type of the content object
+            content_type: nil,
+            # Conversation ID
+            conversation_id: nil,
+            # Content language
+            language: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                content: String,
+                flagged: T::Boolean,
+                labels:
+                  T::Array[
+                    ModerationAPI::Models::Queue::ItemListResponse::Item::Label
+                  ],
+                status:
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Status::TaggedSymbol,
+                timestamp: Float,
+                actions:
+                  T::Array[
+                    ModerationAPI::Models::Queue::ItemListResponse::Item::Action
+                  ],
+                author_id: String,
+                content_type: String,
+                conversation_id: String,
+                language: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Label < ModerationAPI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Label,
+                  ModerationAPI::Internal::AnyHash
+                )
+              end
+
+            # Whether this label caused a flag
+            sig { returns(T::Boolean) }
+            attr_accessor :flagged
+
+            # Label name
+            sig { returns(String) }
+            attr_accessor :label
+
+            # Confidence score of the label
+            sig { returns(Float) }
+            attr_accessor :score
+
+            sig do
+              params(flagged: T::Boolean, label: String, score: Float).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # Whether this label caused a flag
+              flagged:,
+              # Label name
+              label:,
+              # Confidence score of the label
+              score:
+            )
+            end
+
+            sig do
+              override.returns(
+                { flagged: T::Boolean, label: String, score: Float }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          # Status of the item
+          module Status
+            extend ModerationAPI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Status
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            PENDING =
+              T.let(
+                :pending,
+                ModerationAPI::Models::Queue::ItemListResponse::Item::Status::TaggedSymbol
+              )
+            RESOLVED =
+              T.let(
+                :resolved,
+                ModerationAPI::Models::Queue::ItemListResponse::Item::Status::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Status::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          class Action < ModerationAPI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  ModerationAPI::Models::Queue::ItemListResponse::Item::Action,
+                  ModerationAPI::Internal::AnyHash
+                )
+              end
+
+            # Action ID
+            sig { returns(String) }
+            attr_accessor :id
+
+            # Action name
+            sig { returns(String) }
+            attr_accessor :name
+
+            # Unix timestamp of when the action was taken
+            sig { returns(Float) }
+            attr_accessor :timestamp
+
+            # Action comment
+            sig { returns(T.nilable(String)) }
+            attr_reader :comment
+
+            sig { params(comment: String).void }
+            attr_writer :comment
+
+            # Moderator userID
+            sig { returns(T.nilable(String)) }
+            attr_reader :reviewer
+
+            sig { params(reviewer: String).void }
+            attr_writer :reviewer
+
+            sig do
+              params(
+                id: String,
+                name: String,
+                timestamp: Float,
+                comment: String,
+                reviewer: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Action ID
+              id:,
+              # Action name
+              name:,
+              # Unix timestamp of when the action was taken
+              timestamp:,
+              # Action comment
+              comment: nil,
+              # Moderator userID
+              reviewer: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  id: String,
+                  name: String,
+                  timestamp: Float,
+                  comment: String,
+                  reviewer: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
+        class Pagination < ModerationAPI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ModerationAPI::Models::Queue::ItemListResponse::Pagination,
+                ModerationAPI::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Float) }
+          attr_accessor :current_page
+
+          sig { returns(T::Boolean) }
+          attr_accessor :has_next_page
+
+          sig { returns(T::Boolean) }
+          attr_accessor :has_previous_page
+
+          sig { returns(Float) }
+          attr_accessor :total_items
+
+          sig { returns(Float) }
+          attr_accessor :total_pages
+
+          sig do
+            params(
+              current_page: Float,
+              has_next_page: T::Boolean,
+              has_previous_page: T::Boolean,
+              total_items: Float,
+              total_pages: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            current_page:,
+            has_next_page:,
+            has_previous_page:,
+            total_items:,
+            total_pages:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                current_page: Float,
+                has_next_page: T::Boolean,
+                has_previous_page: T::Boolean,
+                total_items: Float,
+                total_pages: Float
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end