moderation_api 2.41.0 → 3.1.0

data/rbi/moderation_api/resources/actions.rbi

@@ -1,156 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class Actions
-      sig { returns(ModerationAPI::Resources::Actions::Execute) }
-      attr_reader :execute
-
-      # Create an action.
-      sig do
-        params(
-          name: String,
-          built_in: T.nilable(T::Boolean),
-          description: T.nilable(String),
-          filter_in_queue_ids: T::Array[String],
-          free_text: T::Boolean,
-          key: T.nilable(String),
-          position: ModerationAPI::ActionCreateParams::Position::OrSymbol,
-          possible_values:
-            T::Array[ModerationAPI::ActionCreateParams::PossibleValue::OrHash],
-          queue_behaviour:
-            ModerationAPI::ActionCreateParams::QueueBehaviour::OrSymbol,
-          type: T.nilable(ModerationAPI::ActionCreateParams::Type::OrSymbol),
-          value_required: T::Boolean,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::ActionCreateResponse)
-      end
-      def create(
-        # The name of the action.
-        name:,
-        # Whether the action is a built-in action or a custom one.
-        built_in: nil,
-        # The description of the action.
-        description: nil,
-        # The IDs of the queues the action is available in.
-        filter_in_queue_ids: nil,
-        # Whether the action allows any text to be entered as a value or if it must be one
-        # of the possible values.
-        free_text: nil,
-        # User defined key of the action.
-        key: nil,
-        # Show the action in all queues, selected queues or no queues (to use via API
-        # only).
-        position: nil,
-        # The possible values of the action. The user will be prompted to select one of
-        # these values when executing the action.
-        possible_values: nil,
-        # Whether the action resolves and removes the item, unresolves and re-add it to
-        # the queue, or does not change the resolve status.
-        queue_behaviour: nil,
-        # The type of the action.
-        type: nil,
-        # Whether the action requires a value to be executed.
-        value_required: nil,
-        request_options: {}
-      )
-      end
-
-      # Get an action by ID.
-      sig do
-        params(
-          id: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::ActionRetrieveResponse)
-      end
-      def retrieve(
-        # The ID of the action to get.
-        id,
-        request_options: {}
-      )
-      end
-
-      # Update an action.
-      sig do
-        params(
-          id: String,
-          built_in: T.nilable(T::Boolean),
-          description: T.nilable(String),
-          filter_in_queue_ids: T::Array[String],
-          free_text: T::Boolean,
-          key: T.nilable(String),
-          name: String,
-          position: ModerationAPI::ActionUpdateParams::Position::OrSymbol,
-          possible_values:
-            T::Array[ModerationAPI::ActionUpdateParams::PossibleValue::OrHash],
-          queue_behaviour:
-            ModerationAPI::ActionUpdateParams::QueueBehaviour::OrSymbol,
-          type: T.nilable(ModerationAPI::ActionUpdateParams::Type::OrSymbol),
-          value_required: T::Boolean,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::ActionUpdateResponse)
-      end
-      def update(
-        # The ID of the action to update.
-        id,
-        # Whether the action is a built-in action or a custom one.
-        built_in: nil,
-        # The description of the action.
-        description: nil,
-        # The IDs of the queues the action is available in.
-        filter_in_queue_ids: nil,
-        # Whether the action allows any text to be entered as a value or if it must be one
-        # of the possible values.
-        free_text: nil,
-        # User defined key of the action.
-        key: nil,
-        # The name of the action.
-        name: nil,
-        # Show the action in all queues, selected queues or no queues (to use via API
-        # only).
-        position: nil,
-        # The possible values of the action. The user will be prompted to select one of
-        # these values when executing the action.
-        possible_values: nil,
-        # Whether the action resolves and removes the item, unresolves and re-add it to
-        # the queue, or does not change the resolve status.
-        queue_behaviour: nil,
-        # The type of the action.
-        type: nil,
-        # Whether the action requires a value to be executed.
-        value_required: nil,
-        request_options: {}
-      )
-      end
-
-      # List all available moderation actions for the authenticated organization.
-      sig do
-        params(
-          queue_id: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(T::Array[ModerationAPI::Models::ActionListResponseItem])
-      end
-      def list(queue_id: nil, request_options: {})
-      end
-
-      # Delete an action and all of its webhooks.
-      sig do
-        params(
-          id: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::ActionDeleteResponse)
-      end
-      def delete(
-        # The ID of the action to delete.
-        id,
-        request_options: {}
-      )
-      end
-
-      # @api private
-      sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/moderation_api/resources/auth.rbi

@@ -1,28 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class Auth
-      sig do
-        params(request_options: ModerationAPI::RequestOptions::OrHash).returns(
-          ModerationAPI::Models::AuthCreateResponse
-        )
-      end
-      def create(request_options: {})
-      end
-
-      sig do
-        params(request_options: ModerationAPI::RequestOptions::OrHash).returns(
-          ModerationAPI::Models::AuthRetrieveResponse
-        )
-      end
-      def retrieve(request_options: {})
-      end
-
-      # @api private
-      sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/moderation_api/resources/authors.rbi

@@ -1,155 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class Authors
-      # Create a new author. Typically not needed as authors are created automatically
-      # when content is moderated.
-      sig do
-        params(
-          external_id: String,
-          company: T.nilable(String),
-          email: T.nilable(String),
-          external_link: T.nilable(String),
-          first_seen: Float,
-          last_seen: Float,
-          manual_trust_level: T.nilable(Float),
-          metadata: ModerationAPI::AuthorCreateParams::Metadata::OrHash,
-          name: T.nilable(String),
-          profile_picture: T.nilable(String),
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::AuthorCreateResponse)
-      end
-      def create(
-        # External ID of the user, typically the ID of the author in your database.
-        external_id:,
-        # The author's company or organization
-        company: nil,
-        # 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
-
-      # Get detailed information about a specific author including historical data and
-      # analysis
-      sig do
-        params(
-          id: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::AuthorRetrieveResponse)
-      end
-      def retrieve(
-        # Either external ID or the ID assigned by moderation API.
-        id,
-        request_options: {}
-      )
-      end
-
-      # Update the details of a specific author
-      sig do
-        params(
-          id: String,
-          company: T.nilable(String),
-          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(ModerationAPI::Models::AuthorUpdateResponse)
-      end
-      def update(
-        # Either external ID or the ID assigned by moderation API.
-        id,
-        # The author's company or organization
-        company: nil,
-        # 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
-
-      # Get a paginated list of authors with their activity metrics and reputation
-      sig do
-        params(
-          content_types: String,
-          last_active_date: String,
-          member_since_date: String,
-          page_number: Float,
-          page_size: Float,
-          sort_by: ModerationAPI::AuthorListParams::SortBy::OrSymbol,
-          sort_direction:
-            ModerationAPI::AuthorListParams::SortDirection::OrSymbol,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::AuthorListResponse)
-      end
-      def list(
-        content_types: nil,
-        last_active_date: nil,
-        member_since_date: nil,
-        # Page number to fetch
-        page_number: nil,
-        # Number of authors per page
-        page_size: nil,
-        sort_by: nil,
-        # Sort direction
-        sort_direction: nil,
-        request_options: {}
-      )
-      end
-
-      # Delete a specific author. This resets the author: status, blocks, trust level,
-      # metrics and action history are removed. The author is created again with a clean
-      # record the next time content is moderated for the same ID.
-      sig do
-        params(
-          id: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::AuthorDeleteResponse)
-      end
-      def delete(
-        # Either external ID or the ID assigned by moderation API.
-        id,
-        request_options: {}
-      )
-      end
-
-      # @api private
-      sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/moderation_api/resources/content.rbi

@@ -1,136 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class Content
-      # Open a WebSocket to moderate live voice/call audio in real time. Speech is
-      # transcribed and each finalized utterance is moderated by your enabled text
-      # policies; you receive a verdict per utterance as it's spoken.
-      #
-      # **This is a WebSocket upgrade, not a regular HTTP call.** The request body below
-      # documents the frames you _send_ over the socket; the `101` response documents
-      # the events you _receive_.
-      #
-      # - **Auth:** `Authorization: Bearer <api_key>` on the upgrade. A missing/invalid
-      #   key closes `4401`; voice not enabled on the plan/channel closes `4403`.
-      # - **Subprotocol:** request `moderationapi.v1`.
-      # - **Flow:** send one `start` frame, then `media` frames as audio arrives, then
-      #   `stop` (or disconnect). You receive `session.started`, `utterance.final` per
-      #   utterance, optional `utterance.partial`/`warning`, and `session.ended`.
-      # - **Close codes:** `1000` normal · `1011` server error · `4400` bad request ·
-      #   `4401` auth failed · `4403` voice not enabled · `4429` concurrency limit.
-      #
-      # See the
-      # [Real-time voice guide](https://docs.moderationapi.com/content-moderation/real-time-voice)
-      # for the full walkthrough and code examples.
-      sig do
-        params(
-          sec_web_socket_protocol:
-            ModerationAPI::ContentStreamParams::SecWebSocketProtocol::OrSymbol,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).void
-      end
-      def stream(
-        # Requested subprotocol.
-        sec_web_socket_protocol:,
-        request_options: {}
-      )
-      end
-
-      sig do
-        params(
-          content:
-            T.any(
-              ModerationAPI::ContentSubmitParams::Content::Text::OrHash,
-              ModerationAPI::ContentSubmitParams::Content::Image::OrHash,
-              ModerationAPI::ContentSubmitParams::Content::Video::OrHash,
-              ModerationAPI::ContentSubmitParams::Content::Audio::OrHash,
-              ModerationAPI::ContentSubmitParams::Content::Object::OrHash
-            ),
-          author_id: String,
-          channel: String,
-          client_action:
-            ModerationAPI::ContentSubmitParams::ClientAction::OrHash,
-          content_id: String,
-          conversation_id: String,
-          do_not_store: T::Boolean,
-          metadata: T::Hash[Symbol, T.anything],
-          meta_type: ModerationAPI::ContentSubmitParams::MetaType::OrSymbol,
-          policies:
-            T::Array[
-              T.any(
-                ModerationAPI::ContentSubmitParams::Policy::Toxicity::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::PersonalInformation::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::ToxicitySevere::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Hate::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Illicit::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::IllicitDrugs::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::IllicitAlcohol::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::IllicitFirearms::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::IllicitTobacco::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::IllicitGambling::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Cannabis::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Adult::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Crypto::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Sexual::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::SexualMinors::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Flirtation::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Profanity::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Violence::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::SelfHarm::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Spam::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::LowQualityContent::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::FaceDetection::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::SelfPromotion::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Political::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Religion::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::CodeAbuse::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::UnicodeSpoofing::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::PiiMasking::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::URLMasking::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::URLRisk::OrHash,
-                ModerationAPI::ContentSubmitParams::Policy::Guideline::OrHash
-              )
-            ],
-          timestamp: Float,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::ContentSubmitResponse)
-      end
-      def submit(
-        # The content sent for moderation
-        content:,
-        # The author of the content.
-        author_id: nil,
-        # Provide a channel ID or key. Will use the project's default channel if not
-        # provided.
-        channel: nil,
-        # A recommendation from your own client-side flagging (e.g. a banned-IP list or a
-        # third-party tool). Feeds the rules engine and can escalate or override the
-        # recommended action. Does not change whether our analysis flagged the content.
-        client_action: nil,
-        # The unique ID of the content in your database.
-        content_id: nil,
-        # For example the ID of a chat room or a post
-        conversation_id: nil,
-        # Do not store the content. The content won't enter the review queue
-        do_not_store: nil,
-        # Any metadata you want to store with the content
-        metadata: nil,
-        # The meta type of content being moderated
-        meta_type: nil,
-        # (Enterprise) override the channel policies for this moderation request only.
-        policies: nil,
-        # Unix timestamp (in milliseconds) of when the content was created. Use if content
-        # is not submitted in real-time.
-        timestamp: nil,
-        request_options: {}
-      )
-      end
-
-      # @api private
-      sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/moderation_api/resources/queue/items.rbi

@@ -1,95 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class Queue
-      class Items
-        # Get paginated list of items in a moderation queue with filtering options
-        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(ModerationAPI::Models::Queue::ItemListResponse)
-        end
-        def list(
-          # 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
-
-        # Mark a queue item as resolved with a specific moderation action
-        sig do
-          params(
-            item_id: String,
-            id: String,
-            comment: String,
-            request_options: ModerationAPI::RequestOptions::OrHash
-          ).returns(ModerationAPI::Models::Queue::ItemResolveResponse)
-        end
-        def resolve(
-          # Path param: The item ID to resolve
-          item_id,
-          # Path param: The queue ID
-          id:,
-          # Body param: Optional comment
-          comment: nil,
-          request_options: {}
-        )
-        end
-
-        # Mark a previously resolved queue item as unresolved/pending
-        sig do
-          params(
-            item_id: String,
-            id: String,
-            comment: String,
-            request_options: ModerationAPI::RequestOptions::OrHash
-          ).returns(ModerationAPI::Models::Queue::ItemUnresolveResponse)
-        end
-        def unresolve(
-          # Path param: The item ID to unresolve
-          item_id,
-          # Path param: The queue ID
-          id:,
-          # Body param: Optional reason for unresolving the item
-          comment: nil,
-          request_options: {}
-        )
-        end
-
-        # @api private
-        sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end

data/rbi/moderation_api/resources/queue.rbi

@@ -1,47 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class Queue
-      sig { returns(ModerationAPI::Resources::Queue::Items) }
-      attr_reader :items
-
-      # Get a queue
-      sig do
-        params(
-          id: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::QueueRetrieveResponse)
-      end
-      def retrieve(
-        # The queue ID
-        id,
-        request_options: {}
-      )
-      end
-
-      # Get detailed statistics about a moderation queue including review times, action
-      # counts, and trends
-      sig do
-        params(
-          id: String,
-          within_days: String,
-          request_options: ModerationAPI::RequestOptions::OrHash
-        ).returns(ModerationAPI::Models::QueueGetStatsResponse)
-      end
-      def get_stats(
-        # The queue ID
-        id,
-        # Number of days to analyze statistics for
-        within_days: nil,
-        request_options: {}
-      )
-      end
-
-      # @api private
-      sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/moderation_api/resources/webhook_secret.rbi

@@ -1,23 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Resources
-    class WebhookSecret
-      # Get the signing secret used to sign webhook deliveries for this project,
-      # creating one if none exists yet. Verify deliveries by comparing the
-      # `modapi-signature` header to HMAC-SHA256(raw request body, secret) hex-encoded.
-      sig do
-        params(request_options: ModerationAPI::RequestOptions::OrHash).returns(
-          ModerationAPI::Models::WebhookSecretRetrieveResponse
-        )
-      end
-      def retrieve(request_options: {})
-      end
-
-      # @api private
-      sig { params(client: ModerationAPI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end