moderation_api 2.41.0 → 3.0.0

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

@@ -1,245 +0,0 @@
-# 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
-
-        # The queue ID
-        sig { returns(String) }
-        attr_accessor :id
-
-        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(
-            id: String,
-            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(
-          # The queue ID
-          id:,
-          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(
-            {
-              id: String,
-              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

@@ -1,440 +0,0 @@
-# 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