moderation_api 2.41.0 → 3.0.0

data/rbi/moderation_api/models/content_submit_response.rbi

@@ -1,2109 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Models
-    class ContentSubmitResponse < ModerationAPI::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(
-            ModerationAPI::Models::ContentSubmitResponse,
-            ModerationAPI::Internal::AnyHash
-          )
-        end
-
-      # The author of the content if your account has authors enabled. Requires you to
-      # send authorId when submitting content.
-      sig do
-        returns(T.nilable(ModerationAPI::Models::ContentSubmitResponse::Author))
-      end
-      attr_reader :author
-
-      sig do
-        params(
-          author:
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Author::OrHash
-            )
-        ).void
-      end
-      attr_writer :author
-
-      # What your casebook — the record of your past moderation decisions — found for
-      # this content, or null when it had nothing close enough to say, when the matching
-      # cases disagreed, or when casebook lookups are not switched on for this channel.
-      # Reports what the casebook found; whether it decided the outcome is shown in
-      # `recommendation`, where a higher-priority rule may have settled the item first.
-      sig do
-        returns(
-          T.nilable(ModerationAPI::Models::ContentSubmitResponse::Casebook)
-        )
-      end
-      attr_reader :casebook
-
-      sig do
-        params(
-          casebook:
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Casebook::OrHash
-            )
-        ).void
-      end
-      attr_writer :casebook
-
-      # Potentially modified content.
-      sig { returns(ModerationAPI::Models::ContentSubmitResponse::Content) }
-      attr_reader :content
-
-      sig do
-        params(
-          content: ModerationAPI::Models::ContentSubmitResponse::Content::OrHash
-        ).void
-      end
-      attr_writer :content
-
-      # The evaluation of the content after running the channel policies.
-      sig { returns(ModerationAPI::Models::ContentSubmitResponse::Evaluation) }
-      attr_reader :evaluation
-
-      sig do
-        params(
-          evaluation:
-            ModerationAPI::Models::ContentSubmitResponse::Evaluation::OrHash
-        ).void
-      end
-      attr_writer :evaluation
-
-      # Results of all insights enabled in the channel.
-      sig do
-        returns(
-          T::Array[
-            ModerationAPI::Models::ContentSubmitResponse::Insight::Variants
-          ]
-        )
-      end
-      attr_accessor :insights
-
-      # Metadata about the moderation request
-      sig { returns(ModerationAPI::Models::ContentSubmitResponse::Meta) }
-      attr_reader :meta
-
-      sig do
-        params(
-          meta: ModerationAPI::Models::ContentSubmitResponse::Meta::OrHash
-        ).void
-      end
-      attr_writer :meta
-
-      # Results of all policies in the channel. Sorted by highest probability.
-      sig do
-        returns(
-          T::Array[
-            ModerationAPI::Models::ContentSubmitResponse::Policy::Variants
-          ]
-        )
-      end
-      attr_accessor :policies
-
-      # The recommendation for the content based on the evaluation.
-      sig do
-        returns(ModerationAPI::Models::ContentSubmitResponse::Recommendation)
-      end
-      attr_reader :recommendation
-
-      sig do
-        params(
-          recommendation:
-            ModerationAPI::Models::ContentSubmitResponse::Recommendation::OrHash
-        ).void
-      end
-      attr_writer :recommendation
-
-      # Policies that had errors
-      sig do
-        returns(
-          T.nilable(
-            T::Array[ModerationAPI::Models::ContentSubmitResponse::Error]
-          )
-        )
-      end
-      attr_reader :errors
-
-      sig do
-        params(
-          errors:
-            T::Array[
-              ModerationAPI::Models::ContentSubmitResponse::Error::OrHash
-            ]
-        ).void
-      end
-      attr_writer :errors
-
-      sig do
-        params(
-          author:
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Author::OrHash
-            ),
-          casebook:
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Casebook::OrHash
-            ),
-          content:
-            ModerationAPI::Models::ContentSubmitResponse::Content::OrHash,
-          evaluation:
-            ModerationAPI::Models::ContentSubmitResponse::Evaluation::OrHash,
-          insights:
-            T::Array[
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::OrHash,
-                ModerationAPI::Models::ContentSubmitResponse::Insight::LanguageInsight::OrHash
-              )
-            ],
-          meta: ModerationAPI::Models::ContentSubmitResponse::Meta::OrHash,
-          policies:
-            T::Array[
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput::OrHash,
-                ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::OrHash
-              )
-            ],
-          recommendation:
-            ModerationAPI::Models::ContentSubmitResponse::Recommendation::OrHash,
-          errors:
-            T::Array[
-              ModerationAPI::Models::ContentSubmitResponse::Error::OrHash
-            ]
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # The author of the content if your account has authors enabled. Requires you to
-        # send authorId when submitting content.
-        author:,
-        # What your casebook — the record of your past moderation decisions — found for
-        # this content, or null when it had nothing close enough to say, when the matching
-        # cases disagreed, or when casebook lookups are not switched on for this channel.
-        # Reports what the casebook found; whether it decided the outcome is shown in
-        # `recommendation`, where a higher-priority rule may have settled the item first.
-        casebook:,
-        # Potentially modified content.
-        content:,
-        # The evaluation of the content after running the channel policies.
-        evaluation:,
-        # Results of all insights enabled in the channel.
-        insights:,
-        # Metadata about the moderation request
-        meta:,
-        # Results of all policies in the channel. Sorted by highest probability.
-        policies:,
-        # The recommendation for the content based on the evaluation.
-        recommendation:,
-        # Policies that had errors
-        errors: nil
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            author:
-              T.nilable(ModerationAPI::Models::ContentSubmitResponse::Author),
-            casebook:
-              T.nilable(ModerationAPI::Models::ContentSubmitResponse::Casebook),
-            content: ModerationAPI::Models::ContentSubmitResponse::Content,
-            evaluation:
-              ModerationAPI::Models::ContentSubmitResponse::Evaluation,
-            insights:
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Insight::Variants
-              ],
-            meta: ModerationAPI::Models::ContentSubmitResponse::Meta,
-            policies:
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Policy::Variants
-              ],
-            recommendation:
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation,
-            errors:
-              T::Array[ModerationAPI::Models::ContentSubmitResponse::Error]
-          }
-        )
-      end
-      def to_hash
-      end
-
-      class Author < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Author,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        # Author ID in Moderation API
-        sig { returns(String) }
-        attr_accessor :id
-
-        # Block or suspension details, if applicable. Null if the author is enabled.
-        sig do
-          returns(
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Author::Block
-            )
-          )
-        end
-        attr_reader :block
-
-        sig do
-          params(
-            block:
-              T.nilable(
-                ModerationAPI::Models::ContentSubmitResponse::Author::Block::OrHash
-              )
-          ).void
-        end
-        attr_writer :block
-
-        # Current author status
-        sig do
-          returns(
-            ModerationAPI::Models::ContentSubmitResponse::Author::Status::TaggedSymbol
-          )
-        end
-        attr_accessor :status
-
-        sig do
-          returns(
-            ModerationAPI::Models::ContentSubmitResponse::Author::TrustLevel
-          )
-        end
-        attr_reader :trust_level
-
-        sig do
-          params(
-            trust_level:
-              ModerationAPI::Models::ContentSubmitResponse::Author::TrustLevel::OrHash
-          ).void
-        end
-        attr_writer :trust_level
-
-        # The author's ID from your system
-        sig { returns(T.nilable(String)) }
-        attr_accessor :external_id
-
-        # The author of the content if your account has authors enabled. Requires you to
-        # send authorId when submitting content.
-        sig do
-          params(
-            id: String,
-            block:
-              T.nilable(
-                ModerationAPI::Models::ContentSubmitResponse::Author::Block::OrHash
-              ),
-            status:
-              ModerationAPI::Models::ContentSubmitResponse::Author::Status::OrSymbol,
-            trust_level:
-              ModerationAPI::Models::ContentSubmitResponse::Author::TrustLevel::OrHash,
-            external_id: T.nilable(String)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Author ID in Moderation API
-          id:,
-          # Block or suspension details, if applicable. Null if the author is enabled.
-          block:,
-          # Current author status
-          status:,
-          trust_level:,
-          # The author's ID from your system
-          external_id: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              id: String,
-              block:
-                T.nilable(
-                  ModerationAPI::Models::ContentSubmitResponse::Author::Block
-                ),
-              status:
-                ModerationAPI::Models::ContentSubmitResponse::Author::Status::TaggedSymbol,
-              trust_level:
-                ModerationAPI::Models::ContentSubmitResponse::Author::TrustLevel,
-              external_id: T.nilable(String)
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Block < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Author::Block,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          # The moderators reason why the author was blocked or suspended.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :reason
-
-          # The timestamp until which they are blocked if the author is suspended.
-          sig { returns(T.nilable(Float)) }
-          attr_accessor :until_
-
-          # Block or suspension details, if applicable. Null if the author is enabled.
-          sig do
-            params(reason: T.nilable(String), until_: T.nilable(Float)).returns(
-              T.attached_class
-            )
-          end
-          def self.new(
-            # The moderators reason why the author was blocked or suspended.
-            reason: nil,
-            # The timestamp until which they are blocked if the author is suspended.
-            until_: nil
-          )
-          end
-
-          sig do
-            override.returns(
-              { reason: T.nilable(String), until_: T.nilable(Float) }
-            )
-          end
-          def to_hash
-          end
-        end
-
-        # Current author status
-        module Status
-          extend ModerationAPI::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                ModerationAPI::Models::ContentSubmitResponse::Author::Status
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          ENABLED =
-            T.let(
-              :enabled,
-              ModerationAPI::Models::ContentSubmitResponse::Author::Status::TaggedSymbol
-            )
-          SUSPENDED =
-            T.let(
-              :suspended,
-              ModerationAPI::Models::ContentSubmitResponse::Author::Status::TaggedSymbol
-            )
-          BLOCKED =
-            T.let(
-              :blocked,
-              ModerationAPI::Models::ContentSubmitResponse::Author::Status::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Author::Status::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-
-        class TrustLevel < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Author::TrustLevel,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          # Author trust level (-1, 0, 1, 2, 3, or 4)
-          sig { returns(Float) }
-          attr_accessor :level
-
-          # True if the trust level was set manually by a moderator
-          sig { returns(T::Boolean) }
-          attr_accessor :manual
-
-          sig do
-            params(level: Float, manual: T::Boolean).returns(T.attached_class)
-          end
-          def self.new(
-            # Author trust level (-1, 0, 1, 2, 3, or 4)
-            level:,
-            # True if the trust level was set manually by a moderator
-            manual:
-          )
-          end
-
-          sig { override.returns({ level: Float, manual: T::Boolean }) }
-          def to_hash
-          end
-        end
-      end
-
-      class Casebook < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Casebook,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        # How unanimous the matching cases are, from 0 to 1: the share of them that
-        # decided this way, ignoring how many there are. Always at least 0.8 when a ruling
-        # is returned — below that the casebook reports a disagreement instead of picking
-        # a side — so it tells you how clean the consensus was, and is not a threshold to
-        # re-apply yourself.
-        sig { returns(Float) }
-        attr_accessor :agreement
-
-        # How many of your past cases backed this ruling.
-        sig { returns(Float) }
-        attr_accessor :case_count
-
-        # How strongly the casebook holds this ruling, from 0 to 1: the agreement scaled
-        # by how much evidence backs it, so a handful of close, recent cases outweighs one
-        # distant one. Older cases count for less, halving in weight roughly every 180
-        # days. This is the number to use in rules when you want a strength condition.
-        sig { returns(Float) }
-        attr_accessor :confidence
-
-        # How close the nearest matching case is, from 0 to 1. 1 means the content is
-        # identical to something you have already decided.
-        sig { returns(Float) }
-        attr_accessor :similarity
-
-        # The topic the closest matching case is filed under, or null when it has not been
-        # grouped into one yet.
-        sig do
-          returns(
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Casebook::Topic
-            )
-          )
-        end
-        attr_reader :topic
-
-        sig do
-          params(
-            topic:
-              T.nilable(
-                ModerationAPI::Models::ContentSubmitResponse::Casebook::Topic::OrHash
-              )
-          ).void
-        end
-        attr_writer :topic
-
-        # The ruling your past decisions point to for this content.
-        sig do
-          returns(
-            ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict::TaggedSymbol
-          )
-        end
-        attr_accessor :verdict
-
-        # What your casebook — the record of your past moderation decisions — found for
-        # this content, or null when it had nothing close enough to say, when the matching
-        # cases disagreed, or when casebook lookups are not switched on for this channel.
-        # Reports what the casebook found; whether it decided the outcome is shown in
-        # `recommendation`, where a higher-priority rule may have settled the item first.
-        sig do
-          params(
-            agreement: Float,
-            case_count: Float,
-            confidence: Float,
-            similarity: Float,
-            topic:
-              T.nilable(
-                ModerationAPI::Models::ContentSubmitResponse::Casebook::Topic::OrHash
-              ),
-            verdict:
-              ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # How unanimous the matching cases are, from 0 to 1: the share of them that
-          # decided this way, ignoring how many there are. Always at least 0.8 when a ruling
-          # is returned — below that the casebook reports a disagreement instead of picking
-          # a side — so it tells you how clean the consensus was, and is not a threshold to
-          # re-apply yourself.
-          agreement:,
-          # How many of your past cases backed this ruling.
-          case_count:,
-          # How strongly the casebook holds this ruling, from 0 to 1: the agreement scaled
-          # by how much evidence backs it, so a handful of close, recent cases outweighs one
-          # distant one. Older cases count for less, halving in weight roughly every 180
-          # days. This is the number to use in rules when you want a strength condition.
-          confidence:,
-          # How close the nearest matching case is, from 0 to 1. 1 means the content is
-          # identical to something you have already decided.
-          similarity:,
-          # The topic the closest matching case is filed under, or null when it has not been
-          # grouped into one yet.
-          topic:,
-          # The ruling your past decisions point to for this content.
-          verdict:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              agreement: Float,
-              case_count: Float,
-              confidence: Float,
-              similarity: Float,
-              topic:
-                T.nilable(
-                  ModerationAPI::Models::ContentSubmitResponse::Casebook::Topic
-                ),
-              verdict:
-                ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict::TaggedSymbol
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Topic < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Casebook::Topic,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(String) }
-          attr_accessor :label
-
-          # The topic the closest matching case is filed under, or null when it has not been
-          # grouped into one yet.
-          sig { params(id: String, label: String).returns(T.attached_class) }
-          def self.new(id:, label:)
-          end
-
-          sig { override.returns({ id: String, label: String }) }
-          def to_hash
-          end
-        end
-
-        # The ruling your past decisions point to for this content.
-        module Verdict
-          extend ModerationAPI::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          ALLOW =
-            T.let(
-              :allow,
-              ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict::TaggedSymbol
-            )
-          REJECT =
-            T.let(
-              :reject,
-              ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Casebook::Verdict::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-      end
-
-      class Content < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Content,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        # The unique identifier for the content. Either the contentId provided by you or
-        # an autogenerated ID.
-        sig { returns(String) }
-        attr_accessor :id
-
-        # Whether any values have been masked.
-        sig { returns(T::Boolean) }
-        attr_accessor :masked
-
-        # The modified content, if any.
-        sig do
-          returns(
-            T.nilable(
-              ModerationAPI::Models::ContentSubmitResponse::Content::Modified::Variants
-            )
-          )
-        end
-        attr_accessor :modified
-
-        # Whether Unicode spoofing normalization rewrote the content — confusables folded
-        # to their Latin lookalikes, invisible characters and combining-mark abuse
-        # stripped.
-        sig { returns(T::Boolean) }
-        attr_accessor :unicode_cleaned
-
-        # The transcribed text from audio content. Only present when audio moderation is
-        # used and transcript inclusion is enabled on the channel.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :transcript
-
-        # Potentially modified content.
-        sig do
-          params(
-            id: String,
-            masked: T::Boolean,
-            modified:
-              T.nilable(
-                ModerationAPI::Models::ContentSubmitResponse::Content::Modified::Variants
-              ),
-            unicode_cleaned: T::Boolean,
-            transcript: T.nilable(String)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The unique identifier for the content. Either the contentId provided by you or
-          # an autogenerated ID.
-          id:,
-          # Whether any values have been masked.
-          masked:,
-          # The modified content, if any.
-          modified:,
-          # Whether Unicode spoofing normalization rewrote the content — confusables folded
-          # to their Latin lookalikes, invisible characters and combining-mark abuse
-          # stripped.
-          unicode_cleaned:,
-          # The transcribed text from audio content. Only present when audio moderation is
-          # used and transcript inclusion is enabled on the channel.
-          transcript: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              id: String,
-              masked: T::Boolean,
-              modified:
-                T.nilable(
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::Variants
-                ),
-              unicode_cleaned: T::Boolean,
-              transcript: T.nilable(String)
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # The modified content, if any.
-        module Modified
-          extend ModerationAPI::Internal::Type::Union
-
-          Variants =
-            T.type_alias do
-              T.any(
-                String,
-                T::Hash[Symbol, T.anything],
-                T::Hash[
-                  Symbol,
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Variants
-                ]
-              )
-            end
-
-          # Text
-          module ModifiedNestedObjectContent
-            extend ModerationAPI::Internal::Type::Union
-
-            Variants =
-              T.type_alias do
-                T.any(
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Text,
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Image,
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Video,
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Audio
-                )
-              end
-
-            class Text < ModerationAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Text,
-                    ModerationAPI::Internal::AnyHash
-                  )
-                end
-
-              # The content text
-              sig { returns(String) }
-              attr_accessor :text
-
-              sig { returns(Symbol) }
-              attr_accessor :type
-
-              # Text
-              sig do
-                params(text: String, type: Symbol).returns(T.attached_class)
-              end
-              def self.new(
-                # The content text
-                text:,
-                type: :text
-              )
-              end
-
-              sig { override.returns({ text: String, type: Symbol }) }
-              def to_hash
-              end
-            end
-
-            class Image < ModerationAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Image,
-                    ModerationAPI::Internal::AnyHash
-                  )
-                end
-
-              sig { returns(Symbol) }
-              attr_accessor :type
-
-              # Base64-encoded image data. Either url or data must be provided. Note: base64
-              # images are not stored and will not appear in the review queue.
-              sig { returns(T.nilable(String)) }
-              attr_reader :data
-
-              sig { params(data: String).void }
-              attr_writer :data
-
-              # A public URL of the image content. Either url or data must be provided.
-              sig { returns(T.nilable(String)) }
-              attr_reader :url
-
-              sig { params(url: String).void }
-              attr_writer :url
-
-              # Image
-              sig do
-                params(data: String, url: String, type: Symbol).returns(
-                  T.attached_class
-                )
-              end
-              def self.new(
-                # Base64-encoded image data. Either url or data must be provided. Note: base64
-                # images are not stored and will not appear in the review queue.
-                data: nil,
-                # A public URL of the image content. Either url or data must be provided.
-                url: nil,
-                type: :image
-              )
-              end
-
-              sig do
-                override.returns({ type: Symbol, data: String, url: String })
-              end
-              def to_hash
-              end
-            end
-
-            class Video < ModerationAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Video,
-                    ModerationAPI::Internal::AnyHash
-                  )
-                end
-
-              sig { returns(Symbol) }
-              attr_accessor :type
-
-              # A public URL of the video content
-              sig { returns(String) }
-              attr_accessor :url
-
-              # Video
-              sig do
-                params(url: String, type: Symbol).returns(T.attached_class)
-              end
-              def self.new(
-                # A public URL of the video content
-                url:,
-                type: :video
-              )
-              end
-
-              sig { override.returns({ type: Symbol, url: String }) }
-              def to_hash
-              end
-            end
-
-            class Audio < ModerationAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Audio,
-                    ModerationAPI::Internal::AnyHash
-                  )
-                end
-
-              sig { returns(Symbol) }
-              attr_accessor :type
-
-              # The URL of the audio content
-              sig { returns(String) }
-              attr_accessor :url
-
-              # Audio
-              sig do
-                params(url: String, type: Symbol).returns(T.attached_class)
-              end
-              def self.new(
-                # The URL of the audio content
-                url:,
-                type: :audio
-              )
-              end
-
-              sig { override.returns({ type: Symbol, url: String }) }
-              def to_hash
-              end
-            end
-
-            sig do
-              override.returns(
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent::Variants
-                ]
-              )
-            end
-            def self.variants
-            end
-          end
-
-          sig do
-            override.returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Content::Modified::Variants
-              ]
-            )
-          end
-          def self.variants
-          end
-
-          ModifiedObjectContentMap =
-            T.let(
-              ModerationAPI::Internal::Type::HashOf[
-                ModerationAPI::Internal::Type::Unknown
-              ],
-              ModerationAPI::Internal::Type::Converter
-            )
-
-          ModifiedNestedObjectContentMap =
-            T.let(
-              ModerationAPI::Internal::Type::HashOf[
-                union:
-                  ModerationAPI::Models::ContentSubmitResponse::Content::Modified::ModifiedNestedObjectContent
-              ],
-              ModerationAPI::Internal::Type::Converter
-            )
-        end
-      end
-
-      class Evaluation < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Evaluation,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        # The probability that the content should be flagged.
-        sig { returns(Float) }
-        attr_accessor :flag_probability
-
-        # Whether the content was flagged by any policy.
-        sig { returns(T::Boolean) }
-        attr_accessor :flagged
-
-        # The severity score of the content. A higher score indicates more severe content.
-        sig { returns(Float) }
-        attr_accessor :severity_score
-
-        # Whether the content would have been flagged by analyze-only policies (flag:
-        # false).
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :shadow_flagged
-
-        sig { params(shadow_flagged: T::Boolean).void }
-        attr_writer :shadow_flagged
-
-        # Whether the content was flagged for Unicode spoofing.
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :unicode_spoofed
-
-        sig { params(unicode_spoofed: T::Boolean).void }
-        attr_writer :unicode_spoofed
-
-        # The evaluation of the content after running the channel policies.
-        sig do
-          params(
-            flag_probability: Float,
-            flagged: T::Boolean,
-            severity_score: Float,
-            shadow_flagged: T::Boolean,
-            unicode_spoofed: T::Boolean
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The probability that the content should be flagged.
-          flag_probability:,
-          # Whether the content was flagged by any policy.
-          flagged:,
-          # The severity score of the content. A higher score indicates more severe content.
-          severity_score:,
-          # Whether the content would have been flagged by analyze-only policies (flag:
-          # false).
-          shadow_flagged: nil,
-          # Whether the content was flagged for Unicode spoofing.
-          unicode_spoofed: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              flag_probability: Float,
-              flagged: T::Boolean,
-              severity_score: Float,
-              shadow_flagged: T::Boolean,
-              unicode_spoofed: T::Boolean
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-
-      # Sentiment insight
-      module Insight
-        extend ModerationAPI::Internal::Type::Union
-
-        Variants =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight,
-              ModerationAPI::Models::ContentSubmitResponse::Insight::LanguageInsight
-            )
-          end
-
-        class SentimentInsight < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          sig { returns(Symbol) }
-          attr_accessor :id
-
-          sig { returns(Float) }
-          attr_accessor :probability
-
-          sig { returns(Symbol) }
-          attr_accessor :type
-
-          sig do
-            returns(
-              T.nilable(
-                ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::TaggedSymbol
-              )
-            )
-          end
-          attr_accessor :value
-
-          # Sentiment insight
-          sig do
-            params(
-              probability: Float,
-              value:
-                T.nilable(
-                  ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::OrSymbol
-                ),
-              id: Symbol,
-              type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(probability:, value:, id: :sentiment, type: :insight)
-          end
-
-          sig do
-            override.returns(
-              {
-                id: Symbol,
-                probability: Float,
-                type: Symbol,
-                value:
-                  T.nilable(
-                    ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::TaggedSymbol
-                  )
-              }
-            )
-          end
-          def to_hash
-          end
-
-          module Value
-            extend ModerationAPI::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            POSITIVE =
-              T.let(
-                :positive,
-                ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::TaggedSymbol
-              )
-            NEUTRAL =
-              T.let(
-                :neutral,
-                ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::TaggedSymbol
-              )
-            NEGATIVE =
-              T.let(
-                :negative,
-                ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Insight::SentimentInsight::Value::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
-        end
-
-        class LanguageInsight < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Insight::LanguageInsight,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          sig { returns(Symbol) }
-          attr_accessor :id
-
-          sig { returns(Float) }
-          attr_accessor :probability
-
-          sig { returns(Symbol) }
-          attr_accessor :type
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :value
-
-          # Language insight
-          sig do
-            params(
-              probability: Float,
-              value: T.nilable(String),
-              id: Symbol,
-              type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(probability:, value:, id: :language, type: :insight)
-          end
-
-          sig do
-            override.returns(
-              {
-                id: Symbol,
-                probability: Float,
-                type: Symbol,
-                value: T.nilable(String)
-              }
-            )
-          end
-          def to_hash
-          end
-        end
-
-        sig do
-          override.returns(
-            T::Array[
-              ModerationAPI::Models::ContentSubmitResponse::Insight::Variants
-            ]
-          )
-        end
-        def self.variants
-        end
-      end
-
-      class Meta < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Meta,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        # The unique key of the channel where the content was handled. Either the channel
-        # provided by you or automatically routed.
-        sig { returns(String) }
-        attr_accessor :channel_key
-
-        sig do
-          returns(
-            ModerationAPI::Models::ContentSubmitResponse::Meta::Status::TaggedSymbol
-          )
-        end
-        attr_accessor :status
-
-        sig { returns(Float) }
-        attr_accessor :timestamp
-
-        sig { returns(Float) }
-        attr_accessor :usage
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :processing_time
-
-        sig { params(processing_time: String).void }
-        attr_writer :processing_time
-
-        # Metadata about the moderation request
-        sig do
-          params(
-            channel_key: String,
-            status:
-              ModerationAPI::Models::ContentSubmitResponse::Meta::Status::OrSymbol,
-            timestamp: Float,
-            usage: Float,
-            processing_time: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The unique key of the channel where the content was handled. Either the channel
-          # provided by you or automatically routed.
-          channel_key:,
-          status:,
-          timestamp:,
-          usage:,
-          processing_time: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              channel_key: String,
-              status:
-                ModerationAPI::Models::ContentSubmitResponse::Meta::Status::TaggedSymbol,
-              timestamp: Float,
-              usage: Float,
-              processing_time: String
-            }
-          )
-        end
-        def to_hash
-        end
-
-        module Status
-          extend ModerationAPI::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                ModerationAPI::Models::ContentSubmitResponse::Meta::Status
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          SUCCESS =
-            T.let(
-              :success,
-              ModerationAPI::Models::ContentSubmitResponse::Meta::Status::TaggedSymbol
-            )
-          PARTIAL_SUCCESS =
-            T.let(
-              :partial_success,
-              ModerationAPI::Models::ContentSubmitResponse::Meta::Status::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Meta::Status::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-      end
-
-      # Policy output schema.
-      module Policy
-        extend ModerationAPI::Internal::Type::Union
-
-        Variants =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput,
-              ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput
-            )
-          end
-
-        class ClassifierOutput < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          # The unique identifier for the classifier output.
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(T::Boolean) }
-          attr_accessor :flagged
-
-          sig { returns(Float) }
-          attr_accessor :probability
-
-          sig { returns(Symbol) }
-          attr_accessor :type
-
-          # Optional structured data produced by the policy. For face detection: { count,
-          # faces: [{ confidence, gender, age }] }.
-          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-          attr_reader :data
-
-          sig { params(data: T::Hash[Symbol, T.anything]).void }
-          attr_writer :data
-
-          # The keys of the flagged fields if submitting an object.
-          sig { returns(T.nilable(T::Array[String])) }
-          attr_reader :flagged_fields
-
-          sig { params(flagged_fields: T::Array[String]).void }
-          attr_writer :flagged_fields
-
-          sig do
-            returns(
-              T.nilable(
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput::Label
-                ]
-              )
-            )
-          end
-          attr_reader :labels
-
-          sig do
-            params(
-              labels:
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput::Label::OrHash
-                ]
-            ).void
-          end
-          attr_writer :labels
-
-          # Classifier policy.
-          sig do
-            params(
-              id: String,
-              flagged: T::Boolean,
-              probability: Float,
-              data: T::Hash[Symbol, T.anything],
-              flagged_fields: T::Array[String],
-              labels:
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput::Label::OrHash
-                ],
-              type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # The unique identifier for the classifier output.
-            id:,
-            flagged:,
-            probability:,
-            # Optional structured data produced by the policy. For face detection: { count,
-            # faces: [{ confidence, gender, age }] }.
-            data: nil,
-            # The keys of the flagged fields if submitting an object.
-            flagged_fields: nil,
-            labels: nil,
-            type: :classifier
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                flagged: T::Boolean,
-                probability: Float,
-                type: Symbol,
-                data: T::Hash[Symbol, T.anything],
-                flagged_fields: T::Array[String],
-                labels:
-                  T::Array[
-                    ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput::Label
-                  ]
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Label < ModerationAPI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::ClassifierOutput::Label,
-                  ModerationAPI::Internal::AnyHash
-                )
-              end
-
-            sig { returns(String) }
-            attr_accessor :id
-
-            sig { returns(T::Boolean) }
-            attr_accessor :flagged
-
-            sig { returns(Float) }
-            attr_accessor :probability
-
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :shadow_flagged
-
-            sig { params(shadow_flagged: T::Boolean).void }
-            attr_writer :shadow_flagged
-
-            sig do
-              params(
-                id: String,
-                flagged: T::Boolean,
-                probability: Float,
-                shadow_flagged: T::Boolean
-              ).returns(T.attached_class)
-            end
-            def self.new(id:, flagged:, probability:, shadow_flagged: nil)
-            end
-
-            sig do
-              override.returns(
-                {
-                  id: String,
-                  flagged: T::Boolean,
-                  probability: Float,
-                  shadow_flagged: T::Boolean
-                }
-              )
-            end
-            def to_hash
-            end
-          end
-        end
-
-        class EntityMatcherOutput < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(T::Boolean) }
-          attr_accessor :flagged
-
-          sig do
-            returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match
-              ]
-            )
-          end
-          attr_accessor :matches
-
-          sig { returns(Float) }
-          attr_accessor :probability
-
-          sig { returns(Symbol) }
-          attr_accessor :type
-
-          sig { returns(T.nilable(T::Array[String])) }
-          attr_reader :flagged_fields
-
-          sig { params(flagged_fields: T::Array[String]).void }
-          attr_writer :flagged_fields
-
-          # Entity matcher policy.
-          sig do
-            params(
-              id: String,
-              flagged: T::Boolean,
-              matches:
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::OrHash
-                ],
-              probability: Float,
-              flagged_fields: T::Array[String],
-              type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            id:,
-            flagged:,
-            matches:,
-            probability:,
-            flagged_fields: nil,
-            type: :entity_matcher
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                flagged: T::Boolean,
-                matches:
-                  T::Array[
-                    ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match
-                  ],
-                probability: Float,
-                type: Symbol,
-                flagged_fields: T::Array[String]
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Match < ModerationAPI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match,
-                  ModerationAPI::Internal::AnyHash
-                )
-              end
-
-            sig { returns(String) }
-            attr_accessor :match
-
-            sig { returns(Float) }
-            attr_accessor :probability
-
-            sig { returns(T::Array[Integer]) }
-            attr_accessor :span
-
-            # Sub-type of the entity match — e.g. the NER key (email, phone, name, …) for PII
-            # matches. Absent for URL Risk and wordlist matches where the type is already
-            # encoded in the parent label.
-            sig { returns(T.nilable(String)) }
-            attr_reader :entity_type
-
-            sig { params(entity_type: String).void }
-            attr_writer :entity_type
-
-            # Stable codes explaining why a URL was flagged (URL Risk only).
-            sig { returns(T.nilable(T::Array[String])) }
-            attr_reader :reasons
-
-            sig { params(reasons: T::Array[String]).void }
-            attr_writer :reasons
-
-            # Observable properties of a URL (URL Risk only). Absent for allow/block list
-            # matches.
-            sig do
-              returns(
-                T.nilable(
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals
-                )
-              )
-            end
-            attr_reader :signals
-
-            sig do
-              params(
-                signals:
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::OrHash
-              ).void
-            end
-            attr_writer :signals
-
-            sig do
-              params(
-                match: String,
-                probability: Float,
-                span: T::Array[Integer],
-                entity_type: String,
-                reasons: T::Array[String],
-                signals:
-                  ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::OrHash
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              match:,
-              probability:,
-              span:,
-              # Sub-type of the entity match — e.g. the NER key (email, phone, name, …) for PII
-              # matches. Absent for URL Risk and wordlist matches where the type is already
-              # encoded in the parent label.
-              entity_type: nil,
-              # Stable codes explaining why a URL was flagged (URL Risk only).
-              reasons: nil,
-              # Observable properties of a URL (URL Risk only). Absent for allow/block list
-              # matches.
-              signals: nil
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  match: String,
-                  probability: Float,
-                  span: T::Array[Integer],
-                  entity_type: String,
-                  reasons: T::Array[String],
-                  signals:
-                    ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals
-                }
-              )
-            end
-            def to_hash
-            end
-
-            class Signals < ModerationAPI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals,
-                    ModerationAPI::Internal::AnyHash
-                  )
-                end
-
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_accessor :bot_protection
-
-              sig do
-                returns(
-                  T.nilable(
-                    ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation
-                  )
-                )
-              end
-              attr_reader :brand_impersonation
-
-              sig do
-                params(
-                  brand_impersonation:
-                    T.nilable(
-                      ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::OrHash
-                    )
-                ).void
-              end
-              attr_writer :brand_impersonation
-
-              sig { returns(T.nilable(Integer)) }
-              attr_accessor :domain_age_days
-
-              sig { returns(T.nilable(String)) }
-              attr_accessor :final_url
-
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_accessor :has_email_setup
-
-              sig { returns(T::Boolean) }
-              attr_accessor :has_suspicious_characters
-
-              sig { returns(T::Boolean) }
-              attr_accessor :is_link_shortener
-
-              sig { returns(T::Boolean) }
-              attr_accessor :is_reported
-
-              sig { returns(T.nilable(Integer)) }
-              attr_accessor :redirect_count
-
-              # Observable properties of a URL (URL Risk only). Absent for allow/block list
-              # matches.
-              sig do
-                params(
-                  bot_protection: T.nilable(T::Boolean),
-                  brand_impersonation:
-                    T.nilable(
-                      ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::OrHash
-                    ),
-                  domain_age_days: T.nilable(Integer),
-                  final_url: T.nilable(String),
-                  has_email_setup: T.nilable(T::Boolean),
-                  has_suspicious_characters: T::Boolean,
-                  is_link_shortener: T::Boolean,
-                  is_reported: T::Boolean,
-                  redirect_count: T.nilable(Integer)
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                bot_protection:,
-                brand_impersonation:,
-                domain_age_days:,
-                final_url:,
-                has_email_setup:,
-                has_suspicious_characters:,
-                is_link_shortener:,
-                is_reported:,
-                redirect_count:
-              )
-              end
-
-              sig do
-                override.returns(
-                  {
-                    bot_protection: T.nilable(T::Boolean),
-                    brand_impersonation:
-                      T.nilable(
-                        ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation
-                      ),
-                    domain_age_days: T.nilable(Integer),
-                    final_url: T.nilable(String),
-                    has_email_setup: T.nilable(T::Boolean),
-                    has_suspicious_characters: T::Boolean,
-                    is_link_shortener: T::Boolean,
-                    is_reported: T::Boolean,
-                    redirect_count: T.nilable(Integer)
-                  }
-                )
-              end
-              def to_hash
-              end
-
-              class BrandImpersonation < ModerationAPI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation,
-                      ModerationAPI::Internal::AnyHash
-                    )
-                  end
-
-                sig { returns(String) }
-                attr_accessor :brand
-
-                sig do
-                  returns(
-                    ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method::TaggedSymbol
-                  )
-                end
-                attr_accessor :method_
-
-                sig do
-                  params(
-                    brand: String,
-                    method_:
-                      ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method::OrSymbol
-                  ).returns(T.attached_class)
-                end
-                def self.new(brand:, method_:)
-                end
-
-                sig do
-                  override.returns(
-                    {
-                      brand: String,
-                      method_:
-                        ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method::TaggedSymbol
-                    }
-                  )
-                end
-                def to_hash
-                end
-
-                module Method
-                  extend ModerationAPI::Internal::Type::Enum
-
-                  TaggedSymbol =
-                    T.type_alias do
-                      T.all(
-                        Symbol,
-                        ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method
-                      )
-                    end
-                  OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-                  REGISTERED_DOMAIN_TOKEN =
-                    T.let(
-                      :registered_domain_token,
-                      ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method::TaggedSymbol
-                    )
-                  SUBDOMAIN_TOKEN =
-                    T.let(
-                      :subdomain_token,
-                      ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method::TaggedSymbol
-                    )
-
-                  sig do
-                    override.returns(
-                      T::Array[
-                        ModerationAPI::Models::ContentSubmitResponse::Policy::EntityMatcherOutput::Match::Signals::BrandImpersonation::Method::TaggedSymbol
-                      ]
-                    )
-                  end
-                  def self.values
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        sig do
-          override.returns(
-            T::Array[
-              ModerationAPI::Models::ContentSubmitResponse::Policy::Variants
-            ]
-          )
-        end
-        def self.variants
-        end
-      end
-
-      class Recommendation < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        # The action to take based on the recommendation
-        sig do
-          returns(
-            ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::TaggedSymbol
-          )
-        end
-        attr_accessor :action
-
-        # Reason codes for the recommendation. Standard codes plus a `rule:<key>` code
-        # identifying the rule that produced the action. Can be used to display a reason
-        # to the user.
-        sig do
-          returns(
-            T::Array[
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::Variants
-            ]
-          )
-        end
-        attr_accessor :reason_codes
-
-        # Rules that matched during evaluation, if rules engine is active.
-        sig do
-          returns(
-            T.nilable(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::MatchedRule
-              ]
-            )
-          )
-        end
-        attr_reader :matched_rules
-
-        sig do
-          params(
-            matched_rules:
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::MatchedRule::OrHash
-              ]
-          ).void
-        end
-        attr_writer :matched_rules
-
-        # The recommendation for the content based on the evaluation.
-        sig do
-          params(
-            action:
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::OrSymbol,
-            reason_codes:
-              T::Array[
-                T.any(
-                  ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::OrSymbol,
-                  String
-                )
-              ],
-            matched_rules:
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::MatchedRule::OrHash
-              ]
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The action to take based on the recommendation
-          action:,
-          # Reason codes for the recommendation. Standard codes plus a `rule:<key>` code
-          # identifying the rule that produced the action. Can be used to display a reason
-          # to the user.
-          reason_codes:,
-          # Rules that matched during evaluation, if rules engine is active.
-          matched_rules: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              action:
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::TaggedSymbol,
-              reason_codes:
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::Variants
-                ],
-              matched_rules:
-                T::Array[
-                  ModerationAPI::Models::ContentSubmitResponse::Recommendation::MatchedRule
-                ]
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # The action to take based on the recommendation
-        module Action
-          extend ModerationAPI::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          REVIEW =
-            T.let(
-              :review,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::TaggedSymbol
-            )
-          ALLOW =
-            T.let(
-              :allow,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::TaggedSymbol
-            )
-          REJECT =
-            T.let(
-              :reject,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::Action::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-
-        module ReasonCode
-          extend ModerationAPI::Internal::Type::Union
-
-          Variants =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol,
-                String
-              )
-            end
-
-          sig do
-            override.returns(
-              T::Array[
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::Variants
-              ]
-            )
-          end
-          def self.variants
-          end
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          SEVERITY_REJECT =
-            T.let(
-              :severity_reject,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          SEVERITY_REVIEW =
-            T.let(
-              :severity_review,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          AUTHOR_BLOCK =
-            T.let(
-              :author_block,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          DRY_RUN =
-            T.let(
-              :dry_run,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          TRUSTED_ALLOW =
-            T.let(
-              :trusted_allow,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          UNTRUSTED_SEVERITY =
-            T.let(
-              :untrusted_severity,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          RULE_MATCH =
-            T.let(
-              :rule_match,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          RULE_DEFAULT =
-            T.let(
-              :rule_default,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          RULE_FALLBACK =
-            T.let(
-              :rule_fallback,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          CLIENT_OVERRIDE =
-            T.let(
-              :client_override,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-          CASEBOOK_MATCH =
-            T.let(
-              :casebook_match,
-              ModerationAPI::Models::ContentSubmitResponse::Recommendation::ReasonCode::TaggedSymbol
-            )
-        end
-
-        class MatchedRule < ModerationAPI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                ModerationAPI::Models::ContentSubmitResponse::Recommendation::MatchedRule,
-                ModerationAPI::Internal::AnyHash
-              )
-            end
-
-          sig { returns(String) }
-          attr_accessor :key
-
-          sig { returns(String) }
-          attr_accessor :name
-
-          sig { params(key: String, name: String).returns(T.attached_class) }
-          def self.new(key:, name:)
-          end
-
-          sig { override.returns({ key: String, name: String }) }
-          def to_hash
-          end
-        end
-      end
-
-      class Error < ModerationAPI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              ModerationAPI::Models::ContentSubmitResponse::Error,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        sig { returns(String) }
-        attr_accessor :id
-
-        sig { returns(String) }
-        attr_accessor :message
-
-        sig { params(id: String, message: String).returns(T.attached_class) }
-        def self.new(id:, message:)
-        end
-
-        sig { override.returns({ id: String, message: String }) }
-        def to_hash
-        end
-      end
-    end
-  end
-end