moderation_api 3.1.1 → 3.2.0

data/lib/moderation_api/items.rb

@@ -47,8 +47,8 @@ module ModerationApi
         .returns(Models::Operations::ListQueueItemsResponse)
     }
     def list(request:, timeout_ms: nil, http_headers: nil)
-      # list - Get queue items
-      # Get paginated list of items in a moderation queue with filtering options
+      # list - List queue items
+      # List the items of a review queue, with the filters and the date window of the queue applied. By default only pending items. The list is paginated. Use the item `id` to resolve or unresolve an item.
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
@@ -175,15 +175,14 @@ module ModerationApi
                 id: request.id,
                 page: next_page,
                 page_size: request.page_size,
-                sort_field: request.sort_field,
-                sort_direction: request.sort_direction,
+                sort: request.sort,
+                include_resolved: request.include_resolved,
                 conversation_ids: request.conversation_ids,
                 labels: request.labels,
-                after_date: request.after_date,
-                before_date: request.before_date,
-                include_resolved: request.include_resolved,
                 author_id: request.author_id,
                 filtered_action_ids: request.filtered_action_ids,
+                after_date: request.after_date,
+                before_date: request.before_date,
                 project_id: request.project_id
               ),
               http_headers: http_headers
@@ -366,7 +365,6 @@ module ModerationApi
 
     sig {
       params(
-        body: Models::Operations::ResolveQueueItemRequestBody,
         id: ::String,
         item_id: ::String,
         project_id: T.nilable(::String),
@@ -375,13 +373,12 @@ module ModerationApi
       )
         .returns(Models::Operations::ResolveQueueItemResponse)
     }
-    def resolve(body:, id:, item_id:, project_id: nil, timeout_ms: nil, http_headers: nil)
+    def resolve(id:, item_id:, project_id: nil, timeout_ms: nil, http_headers: nil)
       # resolve - Resolve a queue item
-      # Mark a queue item as resolved with a specific moderation action
+      # Mark an item of a queue as resolved. It is the same as a check-off in the dashboard: the item leaves the pending list and a QUEUE_ITEM_COMPLETED webhook is sent. To also take a moderation action, use `POST /actions/execute`.
       request = Models::Operations::ResolveQueueItemRequest.new(
         id: id,
         item_id: item_id,
-        body: body,
         project_id: project_id
       )
       url, params = @sdk_configuration.get_server_details
@@ -394,6 +391,268 @@ module ModerationApi
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
+      headers["Accept"] = "application/json"
+      headers["user-agent"] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: "resolveQueueItem",
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise "no response"
+        end
+      end
+
+      content_type = http_response.headers.fetch("Content-Type", "application/octet-stream")
+      if Utils.match_status_code(http_response.status, ["200"])
+        if Utils.match_content_type(content_type, "application/json")
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Operations::ResolveQueueItemResponseBody)
+          response = Models::Operations::ResolveQueueItemResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            object: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise(
+            ::ModerationApi::Models::Errors::APIError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["400"])
+        if Utils.match_content_type(content_type, "application/json")
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequestError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise(
+            ::ModerationApi::Models::Errors::APIError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["401"])
+        if Utils.match_content_type(content_type, "application/json")
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::AuthenticationError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise(
+            ::ModerationApi::Models::Errors::APIError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["403"])
+        if Utils.match_content_type(content_type, "application/json")
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::PermissionDeniedError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise(
+            ::ModerationApi::Models::Errors::APIError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["429"])
+        if Utils.match_content_type(content_type, "application/json")
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RateLimitError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise(
+            ::ModerationApi::Models::Errors::APIError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["500"])
+        if Utils.match_content_type(content_type, "application/json")
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::InternalServerError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise(
+            ::ModerationApi::Models::Errors::APIError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["4XX"])
+        raise(
+          ::ModerationApi::Models::Errors::APIError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      elsif Utils.match_status_code(http_response.status, ["5XX"])
+        raise(
+          ::ModerationApi::Models::Errors::APIError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      else
+        raise(
+          ::ModerationApi::Models::Errors::APIError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "Unknown status code received"
+        )
+
+      end
+    end
+
+    sig {
+      params(
+        body: Models::Operations::ResolveQueueItemsRequestBody,
+        id: ::String,
+        project_id: T.nilable(::String),
+        timeout_ms: T.nilable(Integer),
+        http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])
+      )
+        .returns(Models::Operations::ResolveQueueItemsResponse)
+    }
+    def resolve_many(body:, id:, project_id: nil, timeout_ms: nil, http_headers: nil)
+      # resolve_many - Resolve queue items
+      # Mark up to 100 items of a queue as resolved in one request. Each item is resolved the same as with `POST /queue/{id}/items/{itemId}/resolve`. IDs that do not exist in the project are skipped and returned in `notFoundIds`.
+      request = Models::Operations::ResolveQueueItemsRequest.new(
+        id: id,
+        body: body,
+        project_id: project_id
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::ResolveQueueItemsRequest,
+        base_url,
+        "/queue/{id}/items/resolve",
+        request
+      )
+      headers = Utils.get_headers(request)
+      headers = T.cast(headers, T::Hash[String, String])
       req_content_type, data, form = Utils.serialize_request_body(request, false, false, :body, :json)
       headers["content-type"] = req_content_type
       raise StandardError, "request body is required" if data.nil? && form.nil?
@@ -420,7 +679,7 @@ module ModerationApi
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: nil,
-        operation_id: "resolveQueueItem",
+        operation_id: "resolveQueueItems",
         security_source: @sdk_configuration.security_source
       )
 
@@ -481,8 +740,8 @@ module ModerationApi
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Operations::ResolveQueueItemResponseBody)
-          response = Models::Operations::ResolveQueueItemResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Operations::ResolveQueueItemsResponseBody)
+          response = Models::Operations::ResolveQueueItemsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
@@ -643,7 +902,6 @@ module ModerationApi
 
     sig {
       params(
-        body: Models::Operations::UnresolveQueueItemRequestBody,
         id: ::String,
         item_id: ::String,
         project_id: T.nilable(::String),
@@ -652,13 +910,12 @@ module ModerationApi
       )
         .returns(Models::Operations::UnresolveQueueItemResponse)
     }
-    def unresolve(body:, id:, item_id:, project_id: nil, timeout_ms: nil, http_headers: nil)
+    def unresolve(id:, item_id:, project_id: nil, timeout_ms: nil, http_headers: nil)
       # unresolve - Unresolve a queue item
-      # Mark a previously resolved queue item as unresolved/pending
+      # Mark a resolved item of a queue as pending again. It is the same as removing a check-off in the dashboard: the item comes back in the pending list.
       request = Models::Operations::UnresolveQueueItemRequest.new(
         id: id,
         item_id: item_id,
-        body: body,
         project_id: project_id
       )
       url, params = @sdk_configuration.get_server_details
@@ -671,18 +928,6 @@ module ModerationApi
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :body, :json)
-      headers["content-type"] = req_content_type
-      raise StandardError, "request body is required" if data.nil? && form.nil?
-
-      if form && !form.empty?
-        body = Utils.encode_form(form)
-      elsif Utils.match_content_type(req_content_type, "application/x-www-form-urlencoded")
-        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
-      else
-        body = data
-      end
-
       headers["Accept"] = "application/json"
       headers["user-agent"] = @sdk_configuration.user_agent
 
@@ -706,7 +951,6 @@ module ModerationApi
 
       begin
         http_response = T.must(connection).post(url) do |req|
-          req.body = body
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)

data/lib/moderation_api/models/components/badrequesterror_code.rb

@@ -9,13 +9,15 @@ module ModerationApi
       # BadRequestErrorCode - Exactly what went wrong. Stable; safe to branch on. New codes may be added.
       #
       # - `invalid_request`: A parameter is invalid. `message` says which one.
-      # - `project_id_required`: An organization key called a project endpoint without naming the project in `Project-Id`, and the organization has more than one project.
+      # - `project_id_required`: An organization key called a project endpoint without naming the project in `Project-Id`, and the key reaches more than one project. `message` lists the projects it reaches.
+      # - `project_name_ambiguous`: The name in `Project-Id` fits more than one project the key reaches. `message` lists them; name the project by ID instead.
       # - `validation_failed`: The request body does not match the schema. `issues` lists each problem with its `path`.
       class BadRequestErrorCode
         include ::Crystalline::Enum
         enums do
           INVALID_REQUEST = new("invalid_request")
           PROJECT_ID_REQUIRED = new("project_id_required")
+          PROJECT_NAME_AMBIGUOUS = new("project_name_ambiguous")
           VALIDATION_FAILED = new("validation_failed")
         end
 

data/lib/moderation_api/models/components/label.rb

@@ -0,0 +1,85 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module ModerationApi
+  module Models
+    module Components
+
+      class Label
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The label name
+        field(
+          :label,
+          ::String,
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("label"), required: true}}
+        )
+        # Confidence score between 0 and 1
+        field(
+          :score,
+          ::Float,
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("score"), required: true}}
+        )
+        # True if the label was applied manually by a moderator
+        field(
+          :manual,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("manual")}}
+        )
+        # Whether this label crossed its flagging threshold
+        field(
+          :flagged,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("flagged")}}
+        )
+        # Whether this label crossed its threshold under a shadowed policy — reported for visibility, never counted toward a flagging decision
+        field(
+          :shadow_flagged,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("shadow_flagged")}}
+        )
+
+        field(
+          :matches,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::QueueItemMatch)),
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("matches")}}
+        )
+
+        sig {
+          params(
+            label: ::String,
+            score: ::Float,
+            manual: T.nilable(T::Boolean),
+            flagged: T.nilable(T::Boolean),
+            shadow_flagged: T.nilable(T::Boolean),
+            matches: T.nilable(T::Array[Models::Components::QueueItemMatch])
+          )
+            .void
+        }
+        def initialize(label:, score:, manual: nil, flagged: nil, shadow_flagged: nil, matches: nil)
+          @label = label
+          @score = score
+          @manual = manual
+          @flagged = flagged
+          @shadow_flagged = shadow_flagged
+          @matches = matches
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @label == other.label
+          return false unless @score == other.score
+          return false unless @manual == other.manual
+          return false unless @flagged == other.flagged
+          return false unless @shadow_flagged == other.shadow_flagged
+          return false unless @matches == other.matches
+          true
+        end
+      end
+    end
+  end
+end

data/lib/moderation_api/models/components/label.rbi

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class ModerationApi::Models::Components::Label
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class ModerationApi::Models::Components::Label
+  def label
+  end
+
+  def label=(str_)
+  end
+
+  def score
+  end
+
+  def score=(str_)
+  end
+
+  def manual
+  end
+
+  def manual=(str_)
+  end
+
+  def flagged
+  end
+
+  def flagged=(str_)
+  end
+
+  def shadow_flagged
+  end
+
+  def shadow_flagged=(str_)
+  end
+
+  def matches
+  end
+
+  def matches=(str_)
+  end
+end

data/lib/moderation_api/models/components/notfounderror_code.rb

@@ -12,6 +12,7 @@ module ModerationApi
       # - `action_not_found`: The action does not exist.
       # - `author_not_found`: The author does not exist.
       # - `queue_not_found`: The review queue does not exist.
+      # - `queue_item_not_found`: The queue item does not exist in the project.
       # - `wordlist_not_found`: The wordlist does not exist.
       # - `webhook_not_found`: The webhook does not exist.
       # - `project_not_found`: The project does not exist.
@@ -23,6 +24,7 @@ module ModerationApi
           ACTION_NOT_FOUND = new("action_not_found")
           AUTHOR_NOT_FOUND = new("author_not_found")
           QUEUE_NOT_FOUND = new("queue_not_found")
+          QUEUE_ITEM_NOT_FOUND = new("queue_item_not_found")
           WORDLIST_NOT_FOUND = new("wordlist_not_found")
           WEBHOOK_NOT_FOUND = new("webhook_not_found")
           PROJECT_NOT_FOUND = new("project_not_found")

data/lib/moderation_api/models/components/projectapikey.rb

@@ -0,0 +1,65 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module ModerationApi
+  module Models
+    module Components
+
+      class ProjectApiKey
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The ID of the API key.
+        field :id, ::String, {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("id"), required: true}}
+        # The key's name.
+        field(
+          :name,
+          ::String,
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("name"), required: true}}
+        )
+        # The ID of the project the key belongs to.
+        field(
+          :project_id,
+          ::String,
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("projectId"), required: true}}
+        )
+        # When the key was created.
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("createdAt"), required: true}}
+        )
+        # The new secret API key. Use it to moderate content in this project. It is also shown in the project's settings.
+        field(
+          :secret_key,
+          ::String,
+          {'format_json': {'letter_case': ::ModerationApi::Utils.field_name("secretKey"), required: true}}
+        )
+
+        sig {
+          params(id: ::String, name: ::String, project_id: ::String, created_at: ::String, secret_key: ::String).void
+        }
+        def initialize(id:, name:, project_id:, created_at:, secret_key:)
+          @id = id
+          @name = name
+          @project_id = project_id
+          @created_at = created_at
+          @secret_key = secret_key
+        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 @name == other.name
+          return false unless @project_id == other.project_id
+          return false unless @created_at == other.created_at
+          return false unless @secret_key == other.secret_key
+          true
+        end
+      end
+    end
+  end
+end

data/lib/moderation_api/models/components/projectapikey.rbi

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class ModerationApi::Models::Components::ProjectApiKey
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class ModerationApi::Models::Components::ProjectApiKey
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def name
+  end
+
+  def name=(str_)
+  end
+
+  def project_id
+  end
+
+  def project_id=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def secret_key
+  end
+
+  def secret_key=(str_)
+  end
+end

data/lib/moderation_api/models/components/publicauthor.rb

@@ -28,12 +28,12 @@ module ModerationApi
         # Current author status
         field(
           :status,
-          Models::Components::Status,
+          Models::Components::PublicAuthorStatus,
           {
             'format_json': {
               'letter_case': ::ModerationApi::Utils.field_name("status"),
               required: true,
-              'decoder': ::ModerationApi::Utils.open_enum_from_string(Models::Components::Status, false)
+              'decoder': ::ModerationApi::Utils.open_enum_from_string(Models::Components::PublicAuthorStatus, false)
             }
           }
         )
@@ -115,7 +115,7 @@ module ModerationApi
             id: ::String,
             first_seen: ::Float,
             last_seen: ::Float,
-            status: Models::Components::Status,
+            status: Models::Components::PublicAuthorStatus,
             trust_level: Models::Components::TrustLevel,
             metrics: Models::Components::Metrics,
             metadata: Models::Components::Metadata,