calmlens 0.1.1 → 0.17.1

data/lib/calmlens/assets.rb

@@ -7,21 +7,32 @@ module CalmLens
   # (`asset_id:`) or the API's camelCase (`'assetId'`); keys inside `metadata` are sent unchanged.
   # Any method also accepts `request_options: { idempotency_key:, timeout:, open_timeout:, max_retries: }`.
   # Results are Hashes with the API's camelCase string keys. Fields and enum values added to the API
-  # later appear as they are, so compare `moderation.status` and similar values with known strings
+  # later appear as they are, so compare `classification.moderation.status` and similar values with known strings
   # and treat anything else as not ready.
   class Assets < Resource
-    SUBMIT_QUERY_KEYS = %w[name description processingOptions visibility metadata externalId externalUrl
+    SUBMIT_QUERY_KEYS = %w[name description processingOptions visibility metadata authorId context externalId externalUrl
                            folderId uploadPresetId].freeze
     MIN_MULTIPART_IMAGE_BYTES = 10 * 1024 * 1024
     MAX_MULTIPART_IMAGE_BYTES = 20 * 1024 * 1024
-    # Moderation statuses that carry a decision; {#wait_for_decision} returns once an asset has one,
-    # or once its processing status is in {FINISHED_PROCESSING_STATUSES}.
-    DECIDED_MODERATION_STATUSES = %w[approved rejected].freeze
+    # The moderation status before a decision; {#wait_for_decision} returns once an asset has any
+    # other, or once its classification status is in {FINISHED_PROCESSING_STATUSES}.
+    PENDING_MODERATION_STATUS = 'pending'
     # Processing statuses after which no decision will arrive without a retry.
     FINISHED_PROCESSING_STATUSES = %w[failed].freeze
     DECISION_POLL_FIRST_DELAY = 0.5
+    # Each wait between decision checks is this many times the one before, up to DECISION_POLL_MAX_DELAY.
+    DECISION_POLL_FACTOR = 1.5
     DECISION_POLL_MAX_DELAY = 5.0
     DEFAULT_DECISION_TIMEOUT = 60
+    # The lifetime of a signed URL when none is given: 15 minutes.
+    DEFAULT_SIGNED_URL_SECONDS = 15 * 60
+    # The longest signed URL lifetime the API accepts: 24 hours.
+    MAX_SIGNED_URL_SECONDS = 24 * 60 * 60
+    # The operations {#batch} runs: `delete` deletes each asset with its child assets and stored
+    # content; `remove-content` removes its stored content and keeps the record.
+    BATCH_OPERATIONS = %w[delete remove-content].freeze
+    # The most assets one {#batch} request takes.
+    MAX_BATCH_ASSETS = 500
 
     # Searches assets by meaning or keyword.
     # @option options [String] :query
@@ -34,13 +45,13 @@ module CalmLens
 
     # Lists one page of assets.
     # @option options [String] :cursor from the previous page
-    # @option options [Integer] :page_size
-    # @option options [String] :filter an RSQL filter such as `moderation.status==approved`
-    # @option options [Array<Hash>] :ordering `[{field: 'createdAt', direction: 'DESC'}]`
-    # @return [Hash] `{'items', 'total', 'hasMore', 'cursor', 'pageSize'}`
+    # @option options [Integer] :page_size 1 to 100, default 50
+    # @option options [String] :filter an RSQL filter such as `classification.moderation.status==allowed`
+    # @option options [Array<Hash>] :ordering `[{field: 'createdAt', direction: 'desc'}]`
+    # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
     def list(options = {})
       call(options) do |api, request|
-        request('GET', project('assets/page'), query: api, request_options: request)
+        request('GET', project('assets'), query: api, request_options: request)
       end
     end
 
@@ -88,9 +99,10 @@ module CalmLens
       end
     end
 
-    # Waits until an asset's `moderation.status` is `approved` or `rejected`, or its
-    # `processing.status` is `failed`, and returns the asset. It retrieves the asset, waiting 0.5
-    # seconds before the second check and 1.5 times longer each time after that, up to 5 seconds.
+    # Waits until an asset's `classification.moderation.status` is no longer `pending` (`allowed`,
+    # `limited`, `age-restricted`, `blocked` or `purged`), or its `classification.status` is `failed`, and returns
+    # the asset. It retrieves the asset, waiting 0.5 seconds before the second check and 1.5 times
+    # longer each time after that, up to 5 seconds.
     # Webhooks report decisions without polling.
     #
     # `timeout:` is the whole wait in seconds; `request_options: {timeout:}` still limits each request.
@@ -99,7 +111,7 @@ module CalmLens
     # @option options [Numeric] :timeout seconds to wait for a decision (default 60)
     # @return [Hash] the decided asset
     # @raise [TimeoutError] `sdk/timeout` when no decision arrives in time; `details` holds
-    #   `'assetId'` and the last `'processingStatus'` and `'moderationStatus'`.
+    #   `'assetId'` and the last `'classificationStatus'` and `'moderationStatus'`.
     def wait_for_decision(options)
       call(options) do |api, request|
         timeout = api.fetch('timeout', DEFAULT_DECISION_TIMEOUT)
@@ -121,7 +133,7 @@ module CalmLens
       end
     end
 
-    # Processes an asset whose `processing.status` is `failed` again.
+    # Processes an asset whose `classification.status` is `failed` again.
     # @option options [String] :asset_id
     # @return [Hash] the asset
     def retry(options)
@@ -130,8 +142,40 @@ module CalmLens
       end
     end
 
+    # Records a reviewer's decision, replacing the policy's: `classification.moderation.status`
+    # becomes the decision, the decision and note join `classification.moderation.manualReviews` and
+    # the matching `asset.<status>` event is sent with `decided-by: reviewer`. An asset still pending
+    # moderation can only be blocked or purged. Purging needs `confirm_purge: true` and the
+    # `assets:delete` permission, and permanently deletes the stored content. Not retried: it carries
+    # no `Idempotency-Key`.
+    # @option options [String] :asset_id
+    # @option options [String] :decision `allowed`, `limited`, `age-restricted`, `blocked` or `purged`
+    # @option options [String] :note why, 1 to 1499 characters
+    # @option options [Boolean] :confirm_purge must be true to purge
+    # @return [Hash] the asset
+    def decide(options)
+      call(options) do |api, request|
+        request('POST', "/assets/#{Internal.segment(api['assetId'])}/decision", body: without(api, 'assetId'),
+                                                                                request_options: request)
+      end
+    end
+
+    # Completes the policy evidence behind a decided asset's moderation decision: the report's
+    # `classification.moderation.explanationComplete` becomes `true` and every action stays as decided.
+    # With `rerun: true` the asset is moderated again with the project's current policy and returns
+    # in `processing`; use it when the policy changed since the decision (`asset/policy-changed`).
+    # @option options [String] :asset_id
+    # @option options [Boolean] :rerun
+    # @return [Hash] the asset
+    def explain(options)
+      call(options) do |api, request|
+        request('POST', "/assets/#{Internal.segment(api['assetId'])}/explain",
+                body: api['rerun'] ? { 'rerun' => true } : {}, request_options: request)
+      end
+    end
+
     # Removes the stored content and returns the asset with `content.status` `removed` (reason
-    # `requested`); the record and moderation report are kept.
+    # `requested`); the record and classification results are kept.
     # @option options [String] :asset_id
     # @return [Hash] the asset
     def delete_content(options)
@@ -150,6 +194,28 @@ module CalmLens
       end
     end
 
+    # Deletes up to 500 assets (`operation: 'delete'`) or removes their stored content
+    # (`'remove-content'`) in one request. Every asset must exist in the project and the key needs
+    # `assets:delete` for its folder, or nothing is queued. Returns once the operation is queued; the
+    # work runs in the background and records `asset.deleted` or `asset.content-removed` for each
+    # asset. Assets under a safety hold are skipped. Not retried: it carries no `Idempotency-Key`.
+    # @option options [Array<String>] :asset_ids 1 to 500 asset IDs
+    # @option options [String] :operation one of {BATCH_OPERATIONS}
+    # @return [Hash] `{'queued' => true}`
+    def batch(options)
+      call(options) do |api, request|
+        ids = api['assetIds']
+        unless ids.is_a?(Array) && ids.size.between?(1, MAX_BATCH_ASSETS)
+          raise Internal.invalid("asset_ids must list 1 to #{MAX_BATCH_ASSETS} asset IDs")
+        end
+        raise Internal.invalid('Every asset ID must be a non-empty string') unless ids.all? { |id| id.is_a?(String) && !id.empty? }
+        raise Internal.invalid("operation must be one of #{BATCH_OPERATIONS.join(', ')}") unless BATCH_OPERATIONS.include?(api['operation'])
+
+        request('POST', project('assets/batch'), body: { 'assetIds' => ids, 'operation' => api['operation'] },
+                                                 request_options: request)
+      end
+    end
+
     # Moves an asset into a folder, or to the project root with `folder_id: nil`.
     # @option options [String] :asset_id
     # @option options [String, nil] :folder_id
@@ -163,7 +229,7 @@ module CalmLens
 
     # Creates a time-limited URL that delivers private content without an API key.
     # @option options [String] :asset_id
-    # @option options [String] :resource `content` (default) or `preview`
+    # @option options [String] :resource `rendered` (the API's default) or `original`, which takes no lens or transform
     # @option options [Integer] :expires_in_seconds default 900
     # @option options [String] :lens a lens identifier
     # @option options [String, Hash, Array<Hash>] :transform a selector String or structured steps,
@@ -171,16 +237,19 @@ module CalmLens
     # @return [Hash] `{'url', 'expiresAt'}`
     def create_signed_url(options)
       call(options) do |api, request|
-        body = without(api, 'assetId')
+        path = "/assets/#{Internal.segment(api['assetId'])}/signed-url"
+        body = { 'expiresInSeconds' => DEFAULT_SIGNED_URL_SECONDS }.merge(without(api, 'assetId'))
+        check_signed_url(body)
         body['transform'] = Transforms.selector(body['transform']) if body.key?('transform')
-        request('POST', "/assets/#{Internal.segment(api['assetId'])}/signed-url",
-                body: { 'resource' => 'content', 'expiresInSeconds' => 900 }.merge(body),
+        request('POST', path,
+                body: body,
                 request_options: request)
       end
     end
 
     # Uploads content and queues moderation; the call returns before classification finishes.
-    # Watch for `asset.approved` and `asset.rejected` events or retrieve the asset later.
+    # Watch for `asset.allowed`, `asset.limited`, `asset.age-restricted`, `asset.blocked` and
+    # `asset.purged` events or retrieve the asset later.
     #
     # Give exactly one of `content:` (a whole file), `part:` (the first part of a multipart upload) or
     # `url:` (a web page or file to fetch). Content is `{type:, plain_text:}`, `{type:, base64:}` or
@@ -194,6 +263,11 @@ module CalmLens
     # @option options [Hash] :part `{type:, data:, is_final:}` for the first multipart part
     # @option options [Integer] :total_size_in_bytes the whole file's size, for multipart uploads
     # @option options [String] :url
+    # @option options [String] :author_id your identifier for who wrote the content; CalmLens only
+    #   compares it with the author IDs in `context`, to tell which posts share a speaker.
+    # @option options [Hash] :context `{items: [{text:, author_id:}]}`, earlier posts in the
+    #   conversation, oldest first. Only the posts CalmLens uses are sent: the most recent
+    #   {ModerationContext::USED_ITEMS} that fit in {ModerationContext::USED_CHARACTERS} characters.
     # @return [Hash] the asset
     def create(options)
       call(options) { |api, request| submit(api, request, true) }
@@ -201,25 +275,26 @@ module CalmLens
 
     # Uploads content and waits for the moderation decision where the content type supports it.
     # Audio and video are always processed asynchronously. Takes the options of {#create}.
-    # @return [Hash] the asset; publish only when `moderation.status` is `approved` and
-    #   `moderation.action` is nil.
-    def moderate(options)
+    # @return [Hash] the asset; show it to everyone only when `classification.moderation.status` is
+    #   `allowed` or `limited` (reduce the reach of `limited` assets). Serve `age-restricted` assets
+    #   only behind your own age check, through signed URLs.
+    def classify(options)
       call(options) do |api, request|
         content = api['content']
         if content.is_a?(Hash) && content.key?('plainText') && (!content['plainText'].is_a?(String) || content['plainText'].strip.empty?)
-          raise Internal.invalid('Text to moderate must be a non-empty string', ErrorCodes::INVALID_UPLOAD_PAYLOAD)
+          raise Internal.invalid('Text to classify must be a non-empty string', ErrorCodes::INVALID_UPLOAD_PAYLOAD)
         end
 
         submit(api, request, false)
       end
     end
 
-    # Uploads a later part of a multipart upload started with {#create} or {#moderate} and `part:`.
+    # Uploads a later part of a multipart upload started with {#create} or {#classify} and `part:`.
     # The queue mode chosen at the start applies; pass `queue:` only to override it.
     # @option options [String] :asset_id
     # @option options [Hash] :part `{data:, part_number:, is_final:}`; part numbers start at 2.
     # @option options [Boolean] :queue
-    # @return [Hash] the asset; `processing.status` stays `uploading` until the final part.
+    # @return [Hash] the asset; `classification.status` stays `uploading` until the final part.
     def upload_part(options)
       call(options) do |api, request|
         path = "/assets/#{Internal.segment(api['assetId'])}/part"
@@ -232,36 +307,39 @@ module CalmLens
                                  ErrorCodes::INVALID_UPLOAD_PART_NUMBER)
         end
 
-        body = UploadBody.from(part, multipart: true)
+        body = UploadBody.from(part, multipart: true, part_size: !@session.defer_upload_checks)
         query = { 'partNumber' => number, 'isFinal' => part.fetch('isFinal', false), 'sizeInBytes' => body.size }
         query['queue'] = api['queue'] if api.key?('queue')
-        request('POST', path, query: query, raw: body, idempotent: true, request_options: request,
-                              headers: { 'Content-Type' => 'application/octet-stream', 'X-CalmLens-Upload' => 'part' })
+        expect_asset(request('POST', path, query: query, raw: body, idempotent: true, request_options: request, upload: true,
+                                           headers: { 'Content-Type' => 'application/octet-stream', 'X-CalmLens-Upload' => 'part' }))
       end
     end
 
     private
 
+    # Waits between decision checks; a mock client's waits take no real time.
+    def sleep(seconds) = @session.pause(seconds)
+
     def poll_for_decision(asset_id, request_options, timeout)
-      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      deadline = @session.monotonic + timeout
       delay = DECISION_POLL_FIRST_DELAY
       loop do
         asset = retrieve('assetId' => asset_id, 'request_options' => request_options)
-        processing = asset.dig('processing', 'status')
-        moderation = asset.dig('moderation', 'status')
-        return asset if DECIDED_MODERATION_STATUSES.include?(moderation) || FINISHED_PROCESSING_STATUSES.include?(processing)
+        processing = asset.dig('classification', 'status')
+        moderation = asset.dig('classification', 'moderation', 'status')
+        return asset if moderation != PENDING_MODERATION_STATUS || FINISHED_PROCESSING_STATUSES.include?(processing)
 
-        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        remaining = deadline - @session.monotonic
         unless remaining.positive?
           raise TimeoutError.new(SdkErrorCodes::TIMEOUT,
                                  "Asset #{asset['id']} had no moderation decision after #{timeout}s " \
                                  "(processing #{processing}, moderation #{moderation})",
-                                 details: { 'assetId' => asset['id'], 'processingStatus' => processing,
+                                 details: { 'assetId' => asset['id'], 'classificationStatus' => processing,
                                             'moderationStatus' => moderation })
         end
 
         sleep([delay, remaining].min)
-        delay = [delay * 1.5, DECISION_POLL_MAX_DELAY].min
+        delay = [delay * DECISION_POLL_FACTOR, DECISION_POLL_MAX_DELAY].min
       end
     end
 
@@ -271,9 +349,10 @@ module CalmLens
         raise Internal.invalid('Supply exactly one of content, part, or url; isFinal belongs in part',
                                ErrorCodes::INVALID_UPLOAD_PAYLOAD)
       end
+      options = with_used_context(options)
       if options.key?('url')
-        return request('POST', project('assets'), query: { 'queue' => queue }, body: options, idempotent: true,
-                                                  request_options: request_options)
+        return expect_asset(request('POST', project('assets'), query: { 'queue' => queue }, body: options,
+                                                               idempotent: true, request_options: request_options))
       end
 
       multipart = options.key?('part')
@@ -285,21 +364,61 @@ module CalmLens
         raise Internal.invalid('Use uploadPart for multipart upload parts after the first part', ErrorCodes::USE_UPLOAD_PART)
       end
 
-      body = UploadBody.from(content, multipart: multipart)
+      body = UploadBody.from(content, multipart: multipart, part_size: !@session.defer_upload_checks)
       query = options.slice(*SUBMIT_QUERY_KEYS).merge('queue' => queue, 'contentType' => content['type'],
                                                       'sizeInBytes' => body.size)
-      if multipart
-        total = options['totalSizeInBytes']
-        unless total.nil? || (total.is_a?(Integer) && total.positive?)
-          raise Internal.invalid('totalSizeInBytes must be a positive Integer', ErrorCodes::INVALID_UPLOAD_PAYLOAD)
-        end
+      query.merge!(first_part_query(options, content, mime, body)) if multipart
+      expect_asset(request('POST', project('assets'),
+                           query: query, raw: body, idempotent: true, request_options: request_options,
+                           upload: !content.key?('plainText'),
+                           headers: { 'Content-Type' => content['type'], 'X-CalmLens-Upload' => multipart ? 'part' : 'content' }))
+    end
+
+    # Keeps only the earlier posts CalmLens uses, which keeps a raw upload's query short.
+    def with_used_context(options)
+      return options unless options.key?('context')
 
-        check_image_size(total || body.size, total || content.fetch('isFinal', false)) if mime.start_with?('image/')
-        query.merge!('partNumber' => 1, 'isFinal' => content.fetch('isFinal', false), 'totalSizeInBytes' => total)
+      context = options['context']
+      raise Internal.invalid('context must be a Hash with items') unless context.is_a?(Hash) && context.key?('items')
+
+      options.merge('context' => { 'items' => ModerationContext.select_items(context['items']) })
+    end
+
+    # The query of a first multipart part: its number, whether it is the last and the declared total.
+    def first_part_query(options, content, mime, body)
+      total = options['totalSizeInBytes']
+      unless total.nil? || (total.is_a?(Integer) && total.positive?)
+        raise Internal.invalid('totalSizeInBytes must be a positive Integer', ErrorCodes::INVALID_UPLOAD_PAYLOAD)
       end
-      request('POST', project('assets'),
-              query: query, raw: body, idempotent: true, request_options: request_options,
-              headers: { 'Content-Type' => content['type'], 'X-CalmLens-Upload' => multipart ? 'part' : 'content' })
+
+      final = content.fetch('isFinal', false)
+      check_image_size(total || body.size, total || final) if mime.start_with?('image/') && !@session.defer_upload_checks
+      { 'partNumber' => 1, 'isFinal' => final, 'totalSizeInBytes' => total }
+    end
+
+    # Like the API's asset responses: an ID and string statuses for the upload, classification and moderation.
+    def expect_asset(data)
+      valid = data.is_a?(Hash) && data['id'].is_a?(String) && !data['id'].empty? &&
+              data['upload'].is_a?(Hash) && data['upload']['status'].is_a?(String) &&
+              data['classification'].is_a?(Hash) && data['classification']['status'].is_a?(String) &&
+              data.dig('classification', 'moderation').is_a?(Hash) &&
+              data.dig('classification', 'moderation', 'status').is_a?(String)
+      return data if valid
+
+      raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Expected an asset response', status: 200)
+    end
+
+    def check_signed_url(body)
+      resource = body.fetch('resource', 'rendered')
+      raise Internal.invalid("A signed URL's resource must be original or rendered") unless %w[original rendered].include?(resource)
+      if resource == 'original' && (body.key?('lens') || body.key?('transform'))
+        raise Internal.invalid('Lenses and transforms apply only to the rendered resource')
+      end
+
+      expires = body['expiresInSeconds']
+      return if expires.is_a?(Integer) && expires.between?(1, MAX_SIGNED_URL_SECONDS)
+
+      raise Internal.invalid('expires_in_seconds must be a whole number from 1 to 86400')
     end
 
     def check_mime(type)

data/lib/calmlens/cdn.rb

@@ -3,13 +3,22 @@
 module CalmLens
   # CDN URLs and authenticated content delivery. Reach it through {ServerClient#cdn}.
   class CDN < Resource
-    # Builds the CDN URL of an asset's content or preview. Private assets need the API key
+    RESOURCES = %w[original rendered placeholder].freeze
+    private_constant :RESOURCES
+
+    # Builds the CDN URL of an asset's rendered, original or placeholder resource. Private assets need the API key
     # ({#serve}) or a signed URL ({Assets#create_signed_url}).
     # @option options [String] :asset_identifier the asset ID or external ID
-    # @option options [String] :resource `content` (default) or `preview`
+    # @option options [String] :resource `rendered` (default), `original` or `placeholder`. Only `rendered`
+    #   takes a lens or transform. A placeholder is a small blurred PNG that the CDN serves publicly for every
+    #   asset whatever its visibility or moderation status; it needs no age confirmation.
     # @option options [String] :lens a lens identifier
-    # @option options [String, Hash, Array<Hash>] :transform a selector such as `imageTransform[width=200]`,
+    # @option options [String, Hash, Array<Hash>] :transform a selector such as `width=200,fit=cover`,
     #   or structured steps: `{type: 'imageTransform', options: {width: 200}}` or an Array of them
+    # @option options [Hash] :viewer_claims viewer assertions, such as `{age_confirmed: true}`, sent as a JSON
+    #   `viewerClaims` query parameter. The CDN serves an asset whose moderation status is `age-restricted` only
+    #   with `age_confirmed: true`, even with a signed URL or the API key. Set it only where your app has already
+    #   decided the viewer may see age-restricted content.
     # @return [String]
     def get_asset_url(options)
       call(options) { |api, _request| url(api) }
@@ -23,6 +32,7 @@ module CalmLens
     # not raised; check {Response#status}.
     #
     # @option options [String] :asset_identifier
+    # @option options [Hash] :viewer_claims see {#get_asset_url}
     # @option options [Hash] :init `{method: 'GET' | 'HEAD', headers: {...}}`
     # @yieldparam response [Response]
     # @return [Response, Object]
@@ -49,15 +59,27 @@ module CalmLens
     private
 
     def url(api)
-      resource = api.fetch('resource', 'content')
-      raise Internal.invalid('Resource must be content or preview') unless %w[content preview].include?(resource)
+      resource = api.fetch('resource', 'rendered')
+      raise Internal.invalid('Resource must be original, rendered or placeholder') unless RESOURCES.include?(resource)
+
+      transformed = !api['lens'].nil? || !api['transform'].nil?
+      raise Internal.invalid('Lenses and transforms apply only to the rendered resource') if resource == 'original' && transformed
+      raise Internal.invalid('A placeholder takes no lens, transform or ageConfirmed') if resource == 'placeholder' && transformed
 
       url = "#{@session.cdn_base_url}/assets/#{Internal.segment(@session.project_id)}/" \
             "#{Internal.segment(api['assetIdentifier'])}/#{resource}"
       url += "/@#{Internal.segment(api['lens'])}" if api['lens']
       transform = api['transform']
-      url += "#{api['lens'] ? ',' : '/'}#{Transforms.path(transform)}" unless transform.nil? || transform == ''
-      url
+      url += "/#{Transforms.path(transform)}" unless transform.nil? || transform == ''
+
+      claims = api['viewerClaims']
+      if !claims.nil? && (!claims.is_a?(Hash) || (claims.key?('ageConfirmed') && ![true, false].include?(claims['ageConfirmed'])))
+        raise Internal.invalid('Invalid viewerClaims')
+      end
+
+      query = []
+      query << "viewerClaims=#{URI.encode_www_form_component(JSON.generate(api['viewerClaims']))}" if api['viewerClaims']
+      query.empty? ? url : "#{url}?#{query.join('&')}"
     end
   end
 end

data/lib/calmlens/error_codes.rb

@@ -5,20 +5,44 @@
 module CalmLens
   # Error codes the CalmLens API returns, for comparing with {Error#code}.
   module ErrorCodes
+    INVALID_VIEWER_CLAIMS = 'viewer/invalid-claims'
+    AGE_CONFIRMATION_REQUIRED = 'viewer/age-confirmation-required'
+    INVALID_VIEWER_REGION = 'viewer/invalid-region'
+    VIEWER_REGION_REQUIRED = 'viewer/region-required'
+    REGIONAL_EVIDENCE_REQUIRED = 'asset/regional-evidence-required'
+    INVALID_TYPE = 'validation/invalid-type'
+    TOO_SMALL = 'validation/too-small'
+    TOO_BIG = 'validation/too-big'
+    INVALID_FORMAT = 'validation/invalid-format'
+    INVALID_VALUE = 'validation/invalid-value'
+    UNKNOWN_FIELD = 'validation/unknown-field'
+    UNSUPPORTED_CONTENT_TYPE = 'validation/unsupported-content-type'
+    INVALID_FILTER = 'validation/invalid-filter'
+    INVALID_ORDERING_FIELD = 'validation/invalid-ordering-field'
+    ROUTE_NOT_FOUND = 'misc/route-not-found'
+    INTERNAL_ERROR = 'misc/internal-error'
+    UNAUTHENTICATED = 'auth/unauthenticated'
+    TOKEN_EXPIRED = 'auth/token-expired'
+    INVALID_TOKEN = 'auth/invalid-token'
+    SEARCH_UNAVAILABLE = 'search/unavailable'
+    INVALID_TRANSFORM = 'asset/invalid-transform'
+    INVALID_TRANSFORM_OPTIONS = 'asset/invalid-transform-options'
+    REMOTE_URL_REDIRECT_LIMIT = 'asset/remote-url-redirect-limit'
+    COPYRIGHT_CONTENT_HELD = 'copyright/content-held'
+    DOWNLOAD_PERMISSION_REQUIRED = 'asset/api-key-missing-permission'
     INVALID_CURSOR = 'validation/invalid-cursor'
     MISSING_TOKEN = 'auth/missing-token'
     INVALID_API_KEY = 'auth/invalid-api-key'
     API_KEY_PROJECT_MISMATCH = 'auth/project-mismatch'
     API_KEY_NOT_ACCEPTED = 'auth/api-key-not-accepted'
+    PERMISSION_DENIED = 'auth/permission-denied'
     FILE_TOO_LARGE = 'upload/file-too-large'
-    IMAGE_REQUIRES_MULTIPART_UPLOAD = 'upload/image-requires-multipart-upload'
     MULTIPART_IMAGE_TOO_SMALL = 'upload/multipart-image-too-small'
     MULTIPART_IMAGE_TOO_LARGE = 'upload/multipart-image-too-large'
     IMAGE_EXCEEDED_MAX_DIMENSIONS = 'upload/image-exceeded-max-dimensions'
     UPLOAD_LIMIT_EXCEEDED = 'upload/limit-exceeded'
     SPEND_LIMIT_REACHED = 'upload/spend-limit-reached'
     INVALID_UPLOAD_MIME_TYPE = 'upload/invalid-mime-type'
-    INVALID_EVENT_CURSOR = 'events/invalid-cursor'
     INVALID_UPLOAD_PAYLOAD = 'upload/invalid-payload'
     USE_UPLOAD_PART = 'upload/use-upload-part'
     UPLOAD_NOT_OPEN = 'upload/not-open'
@@ -30,10 +54,19 @@ module CalmLens
     IDEMPOTENT_REQUEST_IN_PROGRESS = 'idempotency/request-in-progress'
     ASSET_NOT_FOUND = 'asset/not-found'
     PROJECT_NOT_FOUND = 'project/not-found'
+    ASSET_REVIEW_CHANGED = 'asset/review-changed'
+    ASSET_REVIEW_NOTE_REQUIRED = 'asset/review-note-required'
     ASSET_UPDATE_FAILED = 'asset/update-failed'
     ASSET_SAFETY_HELD = 'asset/safety-held'
+    ASSET_PROCESSING = 'asset/processing'
+    ASSET_DECISION_NOT_ALLOWED = 'asset/decision-not-allowed'
+    ASSET_DECISION_UNCHANGED = 'asset/decision-unchanged'
     ASSET_NOT_RETRYABLE = 'asset/not-retryable'
     ASSET_CONTENT_UNAVAILABLE = 'asset/content-unavailable'
+    ASSET_CONTENT_PURGED = 'asset/content-purged'
+    ASSET_NOT_DECIDED = 'asset/not-decided'
+    ASSET_POLICY_CHANGED = 'asset/policy-changed'
+    ASSET_REVIEWED = 'asset/reviewed'
     SUPPORT_TICKET_NOT_FOUND = 'support/ticket-not-found'
     DUPLICATE_EXTERNAL_ID = 'asset/duplicate-external-id'
     FOLDER_NOT_FOUND = 'folder/not-found'
@@ -41,6 +74,12 @@ module CalmLens
     FOLDER_NOT_EMPTY = 'folder/not-empty'
     FOLDER_PARENT_CYCLE = 'folder/parent-cycle'
     LENS_VERSION_CONFLICT = 'lens/version-conflict'
+    LENS_IDENTIFIER_RESERVED = 'lens/identifier-reserved'
+    HASH_LIST_NOT_FOUND = 'hash-list/not-found'
+    HASH_LIST_ENTRY_NOT_FOUND = 'hash-list/entry-not-found'
+    HASH_LIST_LIMIT_REACHED = 'hash-list/limit-reached'
+    HASH_LIST_ENTRY_LIMIT_REACHED = 'hash-list/entry-limit-reached'
+    HASH_LIST_ASSET_NOT_HASHED = 'hash-list/asset-not-hashed'
     UPLOAD_PRESET_NOT_FOUND = 'upload-preset/not-found'
     UPLOAD_PRESET_DISABLED = 'upload-preset/disabled'
     UPLOAD_PRESET_TOKEN_REQUIRED = 'upload-preset/token-required'
@@ -68,20 +107,44 @@ module CalmLens
 
     # The HTTP status the API returns with each code.
     STATUSES = {
+      'viewer/invalid-claims' => 400,
+      'viewer/age-confirmation-required' => 403,
+      'viewer/invalid-region' => 400,
+      'viewer/region-required' => 403,
+      'asset/regional-evidence-required' => 403,
+      'validation/invalid-type' => 400,
+      'validation/too-small' => 400,
+      'validation/too-big' => 400,
+      'validation/invalid-format' => 400,
+      'validation/invalid-value' => 400,
+      'validation/unknown-field' => 400,
+      'validation/unsupported-content-type' => 415,
+      'validation/invalid-filter' => 400,
+      'validation/invalid-ordering-field' => 400,
+      'misc/route-not-found' => 404,
+      'misc/internal-error' => 500,
+      'auth/unauthenticated' => 401,
+      'auth/token-expired' => 401,
+      'auth/invalid-token' => 401,
+      'search/unavailable' => 503,
+      'asset/invalid-transform' => 400,
+      'asset/invalid-transform-options' => 400,
+      'asset/remote-url-redirect-limit' => 400,
+      'copyright/content-held' => 409,
+      'asset/api-key-missing-permission' => 403,
       'validation/invalid-cursor' => 400,
       'auth/missing-token' => 401,
       'auth/invalid-api-key' => 401,
       'auth/project-mismatch' => 403,
       'auth/api-key-not-accepted' => 403,
+      'auth/permission-denied' => 403,
       'upload/file-too-large' => 400,
-      'upload/image-requires-multipart-upload' => 400,
       'upload/multipart-image-too-small' => 400,
       'upload/multipart-image-too-large' => 400,
       'upload/image-exceeded-max-dimensions' => 400,
       'upload/limit-exceeded' => 403,
       'upload/spend-limit-reached' => 402,
       'upload/invalid-mime-type' => 400,
-      'events/invalid-cursor' => 400,
       'upload/invalid-payload' => 400,
       'upload/use-upload-part' => 409,
       'upload/not-open' => 409,
@@ -93,10 +156,19 @@ module CalmLens
       'idempotency/request-in-progress' => 409,
       'asset/not-found' => 404,
       'project/not-found' => 404,
+      'asset/review-changed' => 409,
+      'asset/review-note-required' => 400,
       'asset/update-failed' => 500,
       'asset/safety-held' => 423,
+      'asset/processing' => 409,
+      'asset/decision-not-allowed' => 409,
+      'asset/decision-unchanged' => 409,
       'asset/not-retryable' => 409,
       'asset/content-unavailable' => 409,
+      'asset/content-purged' => 409,
+      'asset/not-decided' => 409,
+      'asset/policy-changed' => 409,
+      'asset/reviewed' => 409,
       'support/ticket-not-found' => 404,
       'asset/duplicate-external-id' => 409,
       'folder/not-found' => 404,
@@ -104,6 +176,12 @@ module CalmLens
       'folder/not-empty' => 409,
       'folder/parent-cycle' => 409,
       'lens/version-conflict' => 409,
+      'lens/identifier-reserved' => 409,
+      'hash-list/not-found' => 404,
+      'hash-list/entry-not-found' => 404,
+      'hash-list/limit-reached' => 409,
+      'hash-list/entry-limit-reached' => 409,
+      'hash-list/asset-not-hashed' => 409,
       'upload-preset/not-found' => 404,
       'upload-preset/disabled' => 403,
       'upload-preset/token-required' => 401,