calmlens 0.18.3 → 0.20.0

data/lib/calmlens/hash_lists.rb

@@ -5,12 +5,15 @@ module CalmLens
   # project: a `flag` list reports matches, a `block` list also blocks close matches. Reach it through
   # {ServerClient#hash_lists}.
   class HashLists < Resource
+    # The prefix of this resource's operations in Internal::OPTION_KEYS.
+    OPERATIONS = 'hashLists'
+
     # Lists one page of the project's hash lists, newest first.
     # @option options [String] :cursor the previous page's `nextCursor`
     # @option options [Integer] :page_size 1 to 100, default 50
     # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
     def list(options = {})
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         response = request('GET', project('hash-lists'), query: api, request_options: request)
         valid = response.is_a?(Hash) && response['items'].is_a?(Array)
         raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Invalid hash list page') unless valid
@@ -22,7 +25,7 @@ module CalmLens
     # @option options [String] :hash_list_id
     # @return [Hash] the hash list
     def retrieve(options)
-      call(options) { |api, request| request('GET', list_path(api), request_options: request) }
+      call(options, __method__) { |api, request| request('GET', list_path(api), request_options: request) }
     end
 
     # @option options [String] :name
@@ -30,7 +33,7 @@ module CalmLens
     # @option options [String, nil] :description
     # @return [Hash] the hash list
     def create(options)
-      call(options) { |api, request| request('POST', project('hash-lists'), body: api, request_options: request) }
+      call(options, __method__) { |api, request| request('POST', project('hash-lists'), body: api, request_options: request) }
     end
 
     # Renames a list or changes what its matches do. The new action applies to later uploads.
@@ -40,7 +43,7 @@ module CalmLens
     # @option options [String] :action `flag` or `block`
     # @return [Hash] the hash list
     def update(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('PATCH', list_path(api), body: without(api, 'hashListId'), request_options: request)
       end
     end
@@ -49,7 +52,7 @@ module CalmLens
     # @option options [String] :hash_list_id
     # @return [nil]
     def delete(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('DELETE', list_path(api), request_options: request)
         nil
       end
@@ -61,7 +64,7 @@ module CalmLens
     # @option options [Integer] :page_size 1 to 100, default 50
     # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
     def list_entries(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('GET', "#{list_path(api)}/entries", query: without(api, 'hashListId'), request_options: request)
       end
     end
@@ -74,7 +77,7 @@ module CalmLens
     # @option options [String] :label
     # @return [Hash] the entry
     def add_entry(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('POST', "#{list_path(api)}/entries", body: without(api, 'hashListId'), request_options: request)
       end
     end
@@ -82,7 +85,7 @@ module CalmLens
     # @option options [String] :entry_id
     # @return [nil]
     def remove_entry(options)
-      call(options) do |api, request|
+      call(options, __method__) do |api, request|
         request('DELETE', "/hash-list-entries/#{Internal.segment(api['entryId'])}", request_options: request)
         nil
       end

data/lib/calmlens/internal.rb

@@ -79,6 +79,16 @@ module CalmLens
       value.is_a?(Numeric) && value.real? && value.to_f.finite? && value.positive?
     end
 
+    # Whether the API accepts an upload of this MIME type: an image, audio, video, text, document or
+    # website type, not a container such as `application/octet-stream`. It refuses any other type
+    # with `upload/invalid-mime-type`.
+    def accepted_upload_mime_type?(type)
+      mime = type.to_s.split(';', 2).first.to_s.strip.downcase
+      return false if UPLOAD_MIME_REJECTED.include?(mime)
+
+      mime.start_with?(*UPLOAD_MIME_PREFIXES) || mime.end_with?(*UPLOAD_MIME_SUFFIXES) || UPLOAD_MIME_TYPES.include?(mime)
+    end
+
     # Fetches a required option.
     def required(options, key, code = SdkErrorCodes::INVALID_ARGUMENT)
       raise invalid("#{key} is required", code) unless options.key?(key)

data/lib/calmlens/lenses.rb

@@ -4,12 +4,16 @@ module CalmLens
   # Lens definitions, cached per client. Used through {ServerClient#ensure_lenses} and {ServerClient#ensure_lens}.
   # @api private
   class Lenses < Resource
+    # The prefix of this resource's operations in Internal::OPTION_KEYS.
+    OPERATIONS = nil
+
+    # Lens definitions are sent as given, nil fields included.
     def ensure_lenses(options)
-      call(options) { |api, request| @session.ensure_lenses(api['lenses'], request) }
+      call(options, __method__, keep_nil: true) { |api, request| @session.ensure_lenses(api['lenses'], request) }
     end
 
     def ensure_lens(options)
-      call(options) { |api, request| @session.ensure_lenses([api], request).first }
+      call(options, __method__, keep_nil: true) { |api, request| @session.ensure_lenses([api], request).first }
     end
   end
   private_constant :Lenses

data/lib/calmlens/option_keys.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Generated by packages/sdk-contract/generate.ts from packages/shared/src/PublicApiSchemas.ts.
+# Do not edit by hand: run `bun packages/sdk-contract/generate.ts`.
+module CalmLens
+  module Internal
+    # The camelCase option keys each method takes, besides `request_options`.
+    OPTION_KEYS = {
+      'assets.batch' => %w[assetIds operation].freeze,
+      'assets.classify' => %w[
+        authorId content context description externalId externalUrl folderId isFinal metadata name part
+        processingOptions sizeInBytes totalSizeInBytes uploadPresetId url visibility
+      ].freeze,
+      'assets.create' => %w[
+        authorId content context description externalId externalUrl folderId isFinal metadata name part
+        processingOptions sizeInBytes totalSizeInBytes uploadPresetId url visibility
+      ].freeze,
+      'assets.createSignedUrl' => %w[assetId expiresInSeconds lens resource transform viewerClaims].freeze,
+      'assets.decide' => %w[assetId confirmPurge decision note].freeze,
+      'assets.delete' => %w[assetId].freeze,
+      'assets.deleteContent' => %w[assetId].freeze,
+      'assets.each' => %w[cursor filter folderId ordering pageSize].freeze,
+      'assets.eachChild' => %w[assetId cursor ordering pageSize].freeze,
+      'assets.explain' => %w[assetId rerun].freeze,
+      'assets.list' => %w[cursor filter folderId ordering pageSize].freeze,
+      'assets.listChildren' => %w[assetId cursor ordering pageSize].freeze,
+      'assets.move' => %w[assetId folderId].freeze,
+      'assets.retrieve' => %w[assetId].freeze,
+      'assets.retry' => %w[assetId].freeze,
+      'assets.search' => %w[limit mode query].freeze,
+      'assets.update' => %w[assetId description externalId externalUrl metadata name tags visibility].freeze,
+      'assets.uploadPart' => %w[assetId part queue].freeze,
+      'ensureLens' => %w[active description identifier name transform type version].freeze,
+      'ensureLenses' => %w[lenses].freeze,
+      'events.each' => %w[cursor pageSize].freeze,
+      'events.eachPage' => %w[cursor pageSize].freeze,
+      'events.list' => %w[cursor pageSize].freeze,
+      'folders.create' => %w[name parentId].freeze,
+      'folders.delete' => %w[folderId].freeze,
+      'folders.list' => %w[cursor ordering pageSize parentId search].freeze,
+      'folders.move' => %w[folderId parentId].freeze,
+      'folders.retrieve' => %w[folderId].freeze,
+      'folders.update' => %w[folderId name].freeze,
+      'hashLists.addEntry' => %w[assetId hash hashListId label quality].freeze,
+      'hashLists.create' => %w[action description name].freeze,
+      'hashLists.delete' => %w[hashListId].freeze,
+      'hashLists.list' => %w[cursor ordering pageSize].freeze,
+      'hashLists.listEntries' => %w[cursor hashListId ordering pageSize].freeze,
+      'hashLists.removeEntry' => %w[entryId].freeze,
+      'hashLists.retrieve' => %w[hashListId].freeze,
+      'hashLists.update' => %w[action description hashListId name].freeze,
+      'policies.applyPreset' => %w[operation policyId presetVersion revision].freeze,
+      'policies.assign' => %w[policyId].freeze,
+      'policies.create' => %w[description name presetId settings].freeze,
+      'policies.delete' => %w[policyId].freeze,
+      'policies.list' => %w[].freeze,
+      'policies.retrieve' => %w[policyId].freeze,
+      'policies.setAutomaticUpdates' => %w[enabled policyId presetVersion revision].freeze,
+      'policies.update' => %w[description name policyId revision settings].freeze,
+      'text.classify' => %w[
+        authorId context description externalId externalUrl folderId metadata name processingOptions text
+        uploadPresetId visibility
+      ].freeze
+    }.freeze
+
+    # The option keys each method sends as null when given nil; any other option given as nil
+    # is left out, as the API refuses null for it.
+    NULLABLE_OPTION_KEYS = {
+      'assets.classify' => %w[
+        authorId context description externalId folderId metadata processingOptions uploadPresetId visibility
+      ].freeze,
+      'assets.create' => %w[
+        authorId context description externalId folderId metadata processingOptions uploadPresetId visibility
+      ].freeze,
+      'assets.each' => %w[filter folderId].freeze,
+      'assets.list' => %w[filter folderId].freeze,
+      'assets.move' => %w[folderId].freeze,
+      'assets.update' => %w[description externalId externalUrl metadata tags visibility].freeze,
+      'folders.create' => %w[parentId].freeze,
+      'folders.move' => %w[parentId].freeze,
+      'hashLists.addEntry' => %w[label quality].freeze,
+      'hashLists.create' => %w[description].freeze,
+      'hashLists.update' => %w[description].freeze,
+      'text.classify' => %w[
+        authorId context description externalId folderId metadata processingOptions uploadPresetId visibility
+      ].freeze
+    }.freeze
+  end
+end

data/lib/calmlens/policies.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module CalmLens
+  # Moderation policies belong to the project's organisation and its projects share them. Every
+  # change sends the policy's `revision`, so a policy changed since is refused with
+  # `policy/revision-conflict`. Through a project's key you can change only policies no other
+  # project uses or owns. Reach it through {ServerClient#policies}.
+  class Policies < Resource
+    # The prefix of this resource's operations in Internal::OPTION_KEYS.
+    OPERATIONS = 'policies'
+
+    # Lists the organisation's policies, oldest first, and the ID of the one the project uses.
+    # @return [Hash] `policies` and `projectPolicyId`
+    def list(options = {})
+      call(options, __method__) { |_api, request| request('GET', project('policies'), request_options: request) }
+    end
+
+    # @option options [String] :policy_id
+    # @return [Hash] the policy
+    def retrieve(options)
+      call(options, __method__) { |api, request| request('GET', policy_path(api), request_options: request) }
+    end
+
+    # Creates a policy from `settings` (defining every category) with a `name`, or a copy of the
+    # latest release of a built-in preset with `preset_id`. It moderates nothing until it is
+    # assigned to a project or named on an upload preset.
+    # @option options [String] :name required with `settings`; a preset copy defaults to its name
+    # @option options [String] :description
+    # @option options [Hash] :settings
+    # @option options [String] :preset_id `general-community`, `children-platform`, `education-support`
+    #   or `wholesome-community`
+    # @return [Hash] the policy
+    def create(options)
+      call(options, __method__) { |api, request| request('POST', project('policies'), body: api, request_options: request) }
+    end
+
+    # Changes the name, description or settings (complete, defining every category); later
+    # moderation uses them. Saving a policy that follows automatic updates pins it as a copy.
+    # @option options [String] :policy_id
+    # @option options [Integer] :revision the policy's current revision
+    # @option options [String] :name
+    # @option options [String] :description
+    # @option options [Hash] :settings
+    # @return [Hash] the policy
+    def update(options)
+      call(options, __method__) do |api, request|
+        request('PATCH', policy_path(api), body: without(api, 'policyId'), request_options: request)
+      end
+    end
+
+    # Resets a preset copy to its pinned preset version, or updates an unchanged copy to the latest
+    # preset release.
+    # @option options [String] :policy_id
+    # @option options [String] :operation `reset` or `update`
+    # @option options [Integer] :revision the policy's current revision
+    # @option options [Integer] :preset_version `preset.version` to reset, `preset.latestVersion` to update
+    # @return [Hash] the policy
+    def apply_preset(options)
+      call(options, __method__) do |api, request|
+        request('POST', "#{policy_path(api)}/preset", body: without(api, 'policyId'), request_options: request)
+      end
+    end
+
+    # Switches automatic updates on or off for the organisation's own preset policy. Switching on
+    # replaces the saved copy with the latest preset settings under the same ID; switching off pins
+    # the current preset version as a copy with unchanged settings.
+    # @option options [String] :policy_id
+    # @option options [Boolean] :enabled
+    # @option options [Integer] :revision the policy's current revision
+    # @option options [Integer] :preset_version the preset's `latestVersion`
+    # @return [Hash] the policy
+    def set_automatic_updates(options) # rubocop:disable Naming/AccessorMethodName -- the shared SDK surface name
+      call(options, __method__) do |api, request|
+        request('PUT', "#{policy_path(api)}/automatic-updates", body: without(api, 'policyId'), request_options: request)
+      end
+    end
+
+    # Deletes a policy that no project or upload preset uses.
+    # @option options [String] :policy_id
+    # @return [nil]
+    def delete(options)
+      call(options, __method__) do |api, request|
+        request('DELETE', policy_path(api), request_options: request)
+        nil
+      end
+    end
+
+    # Chooses the policy the project moderates with. Later uploads use it, except those through an
+    # upload preset that names its own policy.
+    # @option options [String] :policy_id
+    # @return [Hash] the policy
+    def assign(options)
+      call(options, __method__) { |api, request| request('PUT', project('policy'), body: api, request_options: request) }
+    end
+
+    private
+
+    def policy_path(api) = project("policies/#{Internal.segment(api['policyId'])}")
+  end
+end

data/lib/calmlens/resource.rb

@@ -15,9 +15,28 @@ module CalmLens
 
     private
 
+    # The option keys of methods that send no request of their own, or take options of their own
+    # beside a request's; Internal::OPTION_KEYS, generated from the API, has the rest.
+    LOCAL_OPTION_KEYS = {
+      'assets.waitForDecision' => %w[assetId timeout].freeze,
+      'cdn.getAssetUrl' => %w[assetIdentifier lens resource transform viewerClaims].freeze,
+      'cdn.serve' => %w[assetIdentifier init lens resource transform viewerClaims].freeze,
+      'uploadTokens.sign' => %w[expiresInSeconds externalId uploadPresetId].freeze
+    }.freeze
+    private_constant :LOCAL_OPTION_KEYS
+
     # Runs a public method: splits options, and raises every argument problem as {InvalidArgumentError}.
-    def call(options)
+    # `method` names the public method: an option it doesn't take, such as a misspelt one, raises
+    # `sdk/invalid-argument` instead of being silently dropped.
+    # An option given as nil is left out, as if omitted, unless the API takes null for it
+    # (Internal::NULLABLE_OPTION_KEYS), such as `description: nil` to clear a description;
+    # `keep_nil: true` sends every option as given, as for a lens definition.
+    def call(options, method, keep_nil: false)
+      operation = [self.class::OPERATIONS, Internal.camelize(method)].compact.join('.')
+      check_option_keys(options, operation)
       api, request = Internal.options(options)
+      nullable = Internal::NULLABLE_OPTION_KEYS.fetch(operation, [])
+      api = api.reject { |key, value| value.nil? && !nullable.include?(key) } unless keep_nil
       yield api, request
     rescue Error
       raise
@@ -25,6 +44,18 @@ module CalmLens
       raise InvalidArgumentError.new(SdkErrorCodes::INVALID_ARGUMENT, e.message), cause: e
     end
 
+    def check_option_keys(options, operation)
+      return unless options.is_a?(Hash)
+
+      allowed = LOCAL_OPTION_KEYS.fetch(operation) { Internal::OPTION_KEYS.fetch(operation) }
+      unknown = options.keys.reject do |key|
+        %w[request_options requestOptions].include?(key.to_s) || allowed.include?(Internal.camelize(key))
+      end
+      return if unknown.empty?
+
+      raise Internal.invalid("Unknown option#{'s' if unknown.size > 1} for #{operation}: #{unknown.join(', ')}")
+    end
+
     def request(...) = @session.request(...)
     def project(path) = @session.project(path)
 

data/lib/calmlens/server_client.rb

@@ -25,6 +25,11 @@ module CalmLens
     RETRY_AFTER_MAX = 60
     # The largest response body read, in bytes (32 MiB).
     DEFAULT_MAX_RESPONSE_BYTES = 32 * 1024 * 1024
+    # Content larger than this many bytes is uploaded in parts of this size (8 MiB).
+    DEFAULT_PART_SIZE_BYTES = 8 * 1024 * 1024
+    # The smallest and largest `part_size_bytes`: every part but the last is at least 5 MiB.
+    MIN_PART_SIZE_BYTES = 5 * 1024 * 1024
+    MAX_PART_SIZE_BYTES = 64 * 1024 * 1024
     # The most lens definitions {#ensure_lenses} sends in one request.
     ENSURE_LENSES_MAX_PER_REQUEST = 100
 
@@ -34,6 +39,8 @@ module CalmLens
     attr_reader :folders
     # @return [HashLists]
     attr_reader :hash_lists
+    # @return [Policies]
+    attr_reader :policies
     # @return [Text]
     attr_reader :text
     # @return [UploadTokens]
@@ -62,14 +69,18 @@ module CalmLens
     #   `Retry-After`. Other writes are never retried. 0 disables retries.
     # @param retry_base_delay [Numeric] seconds before the first retry when the API gives no
     #   `Retry-After`; later retries wait up to twice as long each time, at most 8 seconds.
+    # @param part_size_bytes [Integer] content larger than this many bytes whose size the client knows
+    #   and can read again (a binary String, base64, or a File, StringIO or other seekable IO) is
+    #   uploaded in parts of this size: each part is retried on its own, and calling again with the
+    #   same `idempotency_key` resumes an interrupted upload. From 5 MiB to 64 MiB; default 8 MiB.
     # @param transport [#call, nil] a custom {Transport}; defaults to {Transport::NetHTTP}.
     # @raise [ConfigurationError] `sdk/invalid-config` for a missing or malformed setting.
     def initialize(api_key:, project_id:, base_url: DEFAULT_BASE_URL, cdn_base_url: DEFAULT_CDN_BASE_URL,
                    timeout: DEFAULT_TIMEOUT, open_timeout: DEFAULT_OPEN_TIMEOUT, upload_timeout: nil,
                    max_retries: DEFAULT_MAX_RETRIES, retry_base_delay: DEFAULT_RETRY_BASE_DELAY,
-                   max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES, transport: nil)
+                   max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES, part_size_bytes: DEFAULT_PART_SIZE_BYTES, transport: nil)
       check_config(api_key, project_id, timeout, open_timeout, max_retries, retry_base_delay, transport)
-      check_limits(upload_timeout, max_response_bytes)
+      check_limits(upload_timeout, max_response_bytes, part_size_bytes)
       @project_id = project_id
       @base_url = ServerClient.check_url(base_url, 'base_url')
       @cdn_base_url = ServerClient.check_url(cdn_base_url, 'cdn_base_url')
@@ -77,10 +88,11 @@ module CalmLens
                              cdn_base_url: @cdn_base_url, timeout: timeout, open_timeout: open_timeout,
                              max_retries: max_retries, retry_base_delay: retry_base_delay,
                              max_response_bytes: max_response_bytes, upload_timeout: upload_timeout,
-                             transport: transport || Transport::NetHTTP.new)
+                             part_size_bytes: part_size_bytes, transport: transport || Transport::NetHTTP.new)
       @assets = Assets.new(@session)
       @folders = Folders.new(@session)
       @hash_lists = HashLists.new(@session)
+      @policies = Policies.new(@session)
       @text = Text.new(@session, @assets)
       @upload_tokens = UploadTokens.new(@session, api_key)
       @events = Events.new(@session)
@@ -107,11 +119,11 @@ module CalmLens
       nil
     end
 
-    # Creates or updates named lenses (saved transform pipelines) and returns them. Definitions
+    # Creates or updates named lenses (saved transforms) and returns them. Definitions
     # this client already saved are not sent again. Supplying the same definition and version is
     # idempotent; changing a lens needs a higher `version`. More than 100 new definitions are sent in
     # consecutive requests, in order.
-    # @option options [Array<Hash>] :lenses `[{identifier:, name:, type:, version:, transforms:, ...}]`
+    # @option options [Array<Hash>] :lenses `[{identifier:, name:, type:, version:, transform:, ...}]`
     # @return [Array<Hash>] the saved lenses, in the given order.
     def ensure_lenses(options) = @lenses.ensure_lenses(options)
 
@@ -135,10 +147,15 @@ module CalmLens
 
     private
 
-    def check_limits(upload_timeout, max_response_bytes)
+    def check_limits(upload_timeout, max_response_bytes, part_size_bytes)
       unless upload_timeout.nil? || Internal.positive?(upload_timeout)
         raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'upload_timeout must be nil or a positive number of seconds')
       end
+      unless part_size_bytes.is_a?(Integer) && part_size_bytes.between?(MIN_PART_SIZE_BYTES, MAX_PART_SIZE_BYTES)
+        raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG,
+                                     "part_size_bytes must be an Integer from #{MIN_PART_SIZE_BYTES} (5 MiB) to " \
+                                     "#{MAX_PART_SIZE_BYTES} (64 MiB)")
+      end
       return if max_response_bytes.is_a?(Integer) && max_response_bytes.positive?
 
       raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'max_response_bytes must be a positive Integer')

data/lib/calmlens/session.rb

@@ -25,13 +25,16 @@ module CalmLens
     end
 
     attr_reader :project_id, :base_url, :cdn_base_url
+    # Content larger than this many bytes that can be read again is uploaded in parts of this size.
+    attr_reader :part_size_bytes
     # Leaves the upload size checks the API also makes (part and image sizes) to the API, so an
     # offline stand-in answers them like the API does. {MockServerClient} sets it.
     attr_accessor :defer_upload_checks
 
     def initialize(api_key:, project_id:, base_url:, cdn_base_url:, timeout:, open_timeout:, max_retries:,
-                   retry_base_delay:, max_response_bytes:, upload_timeout:, transport:)
+                   retry_base_delay:, max_response_bytes:, upload_timeout:, part_size_bytes:, transport:)
       @api_key = api_key
+      @part_size_bytes = part_size_bytes
       @project_id = project_id
       @base_url = base_url
       @cdn_base_url = cdn_base_url
@@ -161,10 +164,10 @@ module CalmLens
     private
 
     # The fields that identify a lens definition, as canonical JSON: an unset description or
-    # transforms list is the same definition as an explicit null.
+    # transform is the same definition as an explicit null.
     def lens_key(lens)
       fields = { 'identifier' => lens['identifier'], 'name' => lens['name'], 'description' => lens['description'],
-                 'type' => lens['type'], 'transforms' => lens['transforms'] }
+                 'type' => lens['type'], 'transform' => lens['transform'] }
       %w[active version].each { |name| fields[name] = lens[name] if lens.key?(name) }
       JSON.generate(canonical(fields))
     end

data/lib/calmlens/testing/classification.rb

@@ -17,5 +17,8 @@ module CalmLens
       "personal-information" => ["personal-information-contact", "personal-information-email", "personal-information-phone", "personal-information-government-id", "personal-information-financial", "personal-information-location", "personal-information-identifiers", "personal-information-credentials", "personal-information-request", "personal-information-self-disclosure", "personal-information-third-party", "personal-information-historical", "personal-information-documentary", "personal-information-educational", "personal-information-fictional", "personal-information-support-prevention"].freeze,
       "profanity" => ["profanity-mild", "profanity-strong", "profanity-slurs", "profanity-obfuscated", "profanity-historical", "profanity-documentary", "profanity-educational", "profanity-fictional", "profanity-support-prevention"].freeze,
     }.freeze
+
+    # Qualifiers the input type sets, which a test input scenario cannot list.
+    INPUT_QUALIFIERS = ["sexual-text", "violence-text"].freeze
   end
 end