openai 0.80.0 → 0.81.0

data/rbi/openai/models/chat/chat_completion.rbi

@@ -2,14 +2,19 @@
 
 module OpenAI
   module Models
+
     ChatCompletion = Chat::ChatCompletion
 
     module Chat
+
       class ChatCompletion < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(OpenAI::Chat::ChatCompletion, OpenAI::Internal::AnyHash)
-          end
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Chat::ChatCompletion,
+            OpenAI::Internal::AnyHash
+          )
+        end
 
         # A unique identifier for the chat completion.
         sig { returns(String) }
@@ -32,17 +37,21 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :object
 
+        # Set of 16 key-value pairs that can be attached to an object. This can be useful
+        # for storing additional information about the object in a structured format, and
+        # querying for objects via API or the dashboard.
+        #
+        # Keys are strings with a maximum length of 64 characters. Values are strings with
+        # a maximum length of 512 characters.
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_accessor :metadata
+
         # Moderation results for the request input and generated output, if moderated
         # completions were requested.
         sig { returns(T.nilable(OpenAI::Chat::ChatCompletion::Moderation)) }
         attr_reader :moderation
 
-        sig do
-          params(
-            moderation:
-              T.nilable(OpenAI::Chat::ChatCompletion::Moderation::OrHash)
-          ).void
-        end
+        sig { params(moderation: T.nilable(OpenAI::Chat::ChatCompletion::Moderation::OrHash)).void }
         attr_writer :moderation
 
         # Specifies the processing type used for serving the request.
@@ -65,11 +74,7 @@ module OpenAI
         # `service_tier` value based on the processing mode actually used to serve the
         # request. This response value may be different from the value set in the
         # parameter.
-        sig do
-          returns(
-            T.nilable(OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)) }
         attr_accessor :service_tier
 
         # This fingerprint represents the backend configuration that the model runs with.
@@ -93,32 +98,56 @@ module OpenAI
         # input.
         sig do
           params(
+
             id: String,
+
             choices: T::Array[OpenAI::Chat::ChatCompletion::Choice::OrHash],
+
             created: Integer,
+
             model: String,
-            moderation:
-              T.nilable(OpenAI::Chat::ChatCompletion::Moderation::OrHash),
-            service_tier:
-              T.nilable(OpenAI::Chat::ChatCompletion::ServiceTier::OrSymbol),
+
+            metadata: T.nilable(T::Hash[Symbol, String]),
+
+            moderation: T.nilable(OpenAI::Chat::ChatCompletion::Moderation::OrHash),
+
+            service_tier: T.nilable(OpenAI::Chat::ChatCompletion::ServiceTier::OrSymbol),
+
             system_fingerprint: String,
+
             usage: OpenAI::CompletionUsage::OrHash,
+
             object: Symbol
-          ).returns(T.attached_class)
+          )
+            .returns(T.attached_class)
         end
         def self.new(
+
           # A unique identifier for the chat completion.
           id:,
+
           # A list of chat completion choices. Can be more than one if `n` is greater
           # than 1.
           choices:,
+
           # The Unix timestamp (in seconds) of when the chat completion was created.
           created:,
+
           # The model used for the chat completion.
           model:,
+
+          # Set of 16 key-value pairs that can be attached to an object. This can be useful
+          # for storing additional information about the object in a structured format, and
+          # querying for objects via API or the dashboard.
+          #
+          # Keys are strings with a maximum length of 64 characters. Values are strings with
+          # a maximum length of 512 characters.
+          metadata: nil,
+
           # Moderation results for the request input and generated output, if moderated
           # completions were requested.
           moderation: nil,
+
           # Specifies the processing type used for serving the request.
           #
           # - If set to 'auto', then the request will be processed with the service tier
@@ -140,14 +169,18 @@ module OpenAI
           # request. This response value may be different from the value set in the
           # parameter.
           service_tier: nil,
+
           # This fingerprint represents the backend configuration that the model runs with.
           #
           # Can be used in conjunction with the `seed` request parameter to understand when
           # backend changes have been made that might impact determinism.
           system_fingerprint: nil,
+
           # Usage statistics for the completion request.
           usage: nil,
+
           # The object type, which is always `chat.completion`.
+
           object: :"chat.completion"
         )
         end
@@ -160,11 +193,9 @@ module OpenAI
               created: Integer,
               model: String,
               object: Symbol,
+              metadata: T.nilable(T::Hash[Symbol, String]),
               moderation: T.nilable(OpenAI::Chat::ChatCompletion::Moderation),
-              service_tier:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-                ),
+              service_tier: T.nilable(OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol),
               system_fingerprint: String,
               usage: OpenAI::CompletionUsage
             }
@@ -174,13 +205,12 @@ module OpenAI
         end
 
         class Choice < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Chat::ChatCompletion::Choice,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Chat::ChatCompletion::Choice,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # The reason the model stopped generating tokens. This will be `stop` if the model
           # hit a natural stop point or a provided stop sequence, `length` if the maximum
@@ -189,11 +219,7 @@ module OpenAI
           # model called a tool, or `function_call` (deprecated) if the model called a
           # function. Read the [Model Spec](https://model-spec.openai.com/2025-12-18.html)
           # for more.
-          sig do
-            returns(
-              OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-            )
-          end
+          sig { returns(OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol) }
           attr_accessor :finish_reason
 
           # The index of the choice in the list of choices.
@@ -201,43 +227,34 @@ module OpenAI
           attr_accessor :index
 
           # Log probability information for the choice.
-          sig do
-            returns(T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs))
-          end
+          sig { returns(T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs)) }
           attr_reader :logprobs
 
-          sig do
-            params(
-              logprobs:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletion::Choice::Logprobs::OrHash
-                )
-            ).void
-          end
+          sig { params(logprobs: T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs::OrHash)).void }
           attr_writer :logprobs
 
           # A chat completion message generated by the model.
           sig { returns(OpenAI::Chat::ChatCompletionMessage) }
           attr_reader :message
 
-          sig do
-            params(message: OpenAI::Chat::ChatCompletionMessage::OrHash).void
-          end
+          sig { params(message: OpenAI::Chat::ChatCompletionMessage::OrHash).void }
           attr_writer :message
 
           sig do
             params(
-              finish_reason:
-                OpenAI::Chat::ChatCompletion::Choice::FinishReason::OrSymbol,
+
+              finish_reason: OpenAI::Chat::ChatCompletion::Choice::FinishReason::OrSymbol,
+
               index: Integer,
-              logprobs:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletion::Choice::Logprobs::OrHash
-                ),
+
+              logprobs: T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs::OrHash),
+
               message: OpenAI::Chat::ChatCompletionMessage::OrHash
-            ).returns(T.attached_class)
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # The reason the model stopped generating tokens. This will be `stop` if the model
             # hit a natural stop point or a provided stop sequence, `length` if the maximum
             # number of tokens specified in the request was reached, `content_filter` if
@@ -246,11 +263,15 @@ module OpenAI
             # function. Read the [Model Spec](https://model-spec.openai.com/2025-12-18.html)
             # for more.
             finish_reason:,
+
             # The index of the choice in the list of choices.
             index:,
+
             # Log probability information for the choice.
             logprobs:,
+
             # A chat completion message generated by the model.
+
             message:
           )
           end
@@ -258,11 +279,9 @@ module OpenAI
           sig do
             override.returns(
               {
-                finish_reason:
-                  OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol,
+                finish_reason: OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol,
                 index: Integer,
-                logprobs:
-                  T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs),
+                logprobs: T.nilable(OpenAI::Chat::ChatCompletion::Choice::Logprobs),
                 message: OpenAI::Chat::ChatCompletionMessage
               }
             )
@@ -280,94 +299,53 @@ module OpenAI
           module FinishReason
             extend OpenAI::Internal::Type::Enum
 
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  OpenAI::Chat::ChatCompletion::Choice::FinishReason
-                )
-              end
+            TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Chat::ChatCompletion::Choice::FinishReason) }
             OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-            STOP =
-              T.let(
-                :stop,
-                OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-              )
-            LENGTH =
-              T.let(
-                :length,
-                OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-              )
-            TOOL_CALLS =
-              T.let(
-                :tool_calls,
-                OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-              )
-            CONTENT_FILTER =
-              T.let(
-                :content_filter,
-                OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-              )
-            FUNCTION_CALL =
-              T.let(
-                :function_call,
-                OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-              )
+            STOP = T.let(:stop, OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol)
+            LENGTH = T.let(:length, OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol)
+            TOOL_CALLS = T.let(:tool_calls, OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol)
+            CONTENT_FILTER = T.let(:content_filter, OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol)
+            FUNCTION_CALL = T.let(:function_call, OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol)
 
-            sig do
-              override.returns(
-                T::Array[
-                  OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
-                ]
-              )
-            end
+            sig { override.returns(T::Array[OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol]) }
             def self.values
             end
           end
 
           class Logprobs < OpenAI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  OpenAI::Chat::ChatCompletion::Choice::Logprobs,
-                  OpenAI::Internal::AnyHash
-                )
-              end
-
-            # A list of message content tokens with log probability information.
-            sig do
-              returns(
-                T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob])
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Chat::ChatCompletion::Choice::Logprobs,
+                OpenAI::Internal::AnyHash
               )
             end
+
+            # A list of message content tokens with log probability information.
+            sig { returns(T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob])) }
             attr_accessor :content
 
             # A list of message refusal tokens with log probability information.
-            sig do
-              returns(
-                T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob])
-              )
-            end
+            sig { returns(T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob])) }
             attr_accessor :refusal
 
             # Log probability information for the choice.
             sig do
               params(
-                content:
-                  T.nilable(
-                    T::Array[OpenAI::Chat::ChatCompletionTokenLogprob::OrHash]
-                  ),
-                refusal:
-                  T.nilable(
-                    T::Array[OpenAI::Chat::ChatCompletionTokenLogprob::OrHash]
-                  )
-              ).returns(T.attached_class)
+
+                content: T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob::OrHash]),
+
+                refusal: T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob::OrHash])
+              )
+                .returns(T.attached_class)
             end
             def self.new(
+
               # A list of message content tokens with log probability information.
               content:,
+
               # A list of message refusal tokens with log probability information.
+
               refusal:
             )
             end
@@ -375,63 +353,57 @@ module OpenAI
             sig do
               override.returns(
                 {
-                  content:
-                    T.nilable(
-                      T::Array[OpenAI::Chat::ChatCompletionTokenLogprob]
-                    ),
-                  refusal:
-                    T.nilable(
-                      T::Array[OpenAI::Chat::ChatCompletionTokenLogprob]
-                    )
+                  content: T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob]),
+                  refusal: T.nilable(T::Array[OpenAI::Chat::ChatCompletionTokenLogprob])
                 }
               )
             end
             def to_hash
             end
+
           end
         end
 
         class Moderation < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Chat::ChatCompletion::Moderation,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Chat::ChatCompletion::Moderation,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # Moderation for the request input.
-          sig do
-            returns(OpenAI::Chat::ChatCompletion::Moderation::Input::Variants)
-          end
+          sig { returns(OpenAI::Chat::ChatCompletion::Moderation::Input::Variants) }
           attr_accessor :input
 
           # Moderation for the generated output.
-          sig do
-            returns(OpenAI::Chat::ChatCompletion::Moderation::Output::Variants)
-          end
+          sig { returns(OpenAI::Chat::ChatCompletion::Moderation::Output::Variants) }
           attr_accessor :output
 
           # Moderation results for the request input and generated output, if moderated
           # completions were requested.
           sig do
             params(
-              input:
-                T.any(
-                  OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::OrHash,
-                  OpenAI::Chat::ChatCompletion::Moderation::Input::Error::OrHash
-                ),
-              output:
-                T.any(
-                  OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::OrHash,
-                  OpenAI::Chat::ChatCompletion::Moderation::Output::Error::OrHash
-                )
-            ).returns(T.attached_class)
+
+              input: T.any(
+                OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::OrHash,
+                OpenAI::Chat::ChatCompletion::Moderation::Input::Error::OrHash
+              ),
+
+              output: T.any(
+                OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::OrHash,
+                OpenAI::Chat::ChatCompletion::Moderation::Output::Error::OrHash
+              )
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # Moderation for the request input.
             input:,
+
             # Moderation for the generated output.
+
             output:
           )
           end
@@ -439,10 +411,8 @@ module OpenAI
           sig do
             override.returns(
               {
-                input:
-                  OpenAI::Chat::ChatCompletion::Moderation::Input::Variants,
-                output:
-                  OpenAI::Chat::ChatCompletion::Moderation::Output::Variants
+                input: OpenAI::Chat::ChatCompletion::Moderation::Input::Variants,
+                output: OpenAI::Chat::ChatCompletion::Moderation::Output::Variants
               }
             )
           end
@@ -453,35 +423,27 @@ module OpenAI
           module Input
             extend OpenAI::Internal::Type::Union
 
-            Variants =
-              T.type_alias do
+            Variants = T.type_alias {
+              T.any(
+                OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults,
+                OpenAI::Chat::ChatCompletion::Moderation::Input::Error
+              )
+            }
+
+            class ModerationResults < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
                 T.any(
                   OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults,
-                  OpenAI::Chat::ChatCompletion::Moderation::Input::Error
+                  OpenAI::Internal::AnyHash
                 )
               end
 
-            class ModerationResults < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
-
               # The moderation model used to generate the results.
               sig { returns(String) }
               attr_accessor :model
 
               # A list of moderation results.
-              sig do
-                returns(
-                  T::Array[
-                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result
-                  ]
-                )
-              end
+              sig { returns(T::Array[OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result]) }
               attr_accessor :results
 
               # The object type, which is always `moderation_results`.
@@ -491,20 +453,25 @@ module OpenAI
               # Successful moderation results for the request input or generated output.
               sig do
                 params(
+
                   model: String,
-                  results:
-                    T::Array[
-                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::OrHash
-                    ],
+
+                  results: T::Array[OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::OrHash],
+
                   type: Symbol
-                ).returns(T.attached_class)
+                )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 # The moderation model used to generate the results.
                 model:,
+
                 # A list of moderation results.
                 results:,
+
                 # The object type, which is always `moderation_results`.
+
                 type: :moderation_results
               )
               end
@@ -513,10 +480,7 @@ module OpenAI
                 override.returns(
                   {
                     model: String,
-                    results:
-                      T::Array[
-                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result
-                      ],
+                    results: T::Array[OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result],
                     type: Symbol
                   }
                 )
@@ -525,13 +489,12 @@ module OpenAI
               end
 
               class Result < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # A dictionary of moderation categories to booleans, True if the input is flagged
                 # under this category.
@@ -539,7 +502,7 @@ module OpenAI
                 attr_accessor :categories
 
                 # Which modalities of input are reflected by the score for each category.
-                sig do
+                sig {
                   returns(
                     T::Hash[
                       Symbol,
@@ -548,7 +511,7 @@ module OpenAI
                       ]
                     ]
                   )
-                end
+                }
                 attr_accessor :category_applied_input_types
 
                 # A dictionary of moderation categories to scores.
@@ -571,34 +534,47 @@ module OpenAI
                 # A moderation result produced for the response input or output.
                 sig do
                   params(
+
                     categories: T::Hash[Symbol, T::Boolean],
-                    category_applied_input_types:
-                      T::Hash[
-                        Symbol,
-                        T::Array[
-                          OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
-                        ]
-                      ],
+
+                    category_applied_input_types: T::Hash[
+                      Symbol,
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
+                      ]
+                    ],
+
                     category_scores: T::Hash[Symbol, Float],
+
                     flagged: T::Boolean,
+
                     model: String,
+
                     type: Symbol
-                  ).returns(T.attached_class)
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # A dictionary of moderation categories to booleans, True if the input is flagged
                   # under this category.
                   categories:,
+
                   # Which modalities of input are reflected by the score for each category.
                   category_applied_input_types:,
+
                   # A dictionary of moderation categories to scores.
                   category_scores:,
+
                   # A boolean indicating whether the content was flagged by any category.
                   flagged:,
+
                   # The moderation model that produced this result.
                   model:,
+
                   # The object type, which was always `moderation_result` for successful moderation
                   # results.
+
                   type: :moderation_result
                 )
                 end
@@ -607,13 +583,12 @@ module OpenAI
                   override.returns(
                     {
                       categories: T::Hash[Symbol, T::Boolean],
-                      category_applied_input_types:
-                        T::Hash[
-                          Symbol,
-                          T::Array[
-                            OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                          ]
-                        ],
+                      category_applied_input_types: T::Hash[
+                        Symbol,
+                        T::Array[
+                          OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                        ]
+                      ],
                       category_scores: T::Hash[Symbol, Float],
                       flagged: T::Boolean,
                       model: String,
@@ -627,33 +602,30 @@ module OpenAI
                 module CategoryAppliedInputType
                   extend OpenAI::Internal::Type::Enum
 
-                  TaggedSymbol =
-                    T.type_alias do
-                      T.all(
-                        Symbol,
-                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType
-                      )
-                    end
+                  TaggedSymbol = T.type_alias {
+                    T.all(
+                      Symbol,
+                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType
+                    )
+                  }
                   OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                  TEXT =
-                    T.let(
-                      :text,
-                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
-                  IMAGE =
-                    T.let(
-                      :image,
-                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
+                  TEXT = T.let(
+                    :text,
+                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
+                  IMAGE = T.let(
+                    :image,
+                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
 
-                  sig do
+                  sig {
                     override.returns(
                       T::Array[
                         OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
                       ]
                     )
-                  end
+                  }
                   def self.values
                   end
                 end
@@ -661,13 +633,12 @@ module OpenAI
             end
 
             class Error < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletion::Moderation::Input::Error,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::Error,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               # The error code.
               sig { returns(String) }
@@ -683,73 +654,71 @@ module OpenAI
 
               # An error produced while attempting moderation.
               sig do
-                params(code: String, message: String, type: Symbol).returns(
-                  T.attached_class
+                params(
+
+                  code: String,
+
+                  message: String,
+
+                  type: Symbol
                 )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 # The error code.
                 code:,
+
                 # The error message.
                 message:,
+
                 # The object type, which is always `error`.
+
                 type: :error
               )
               end
 
               sig do
                 override.returns(
-                  { code: String, message: String, type: Symbol }
+                  {code: String, message: String, type: Symbol}
                 )
               end
               def to_hash
               end
-            end
 
-            sig do
-              override.returns(
-                T::Array[
-                  OpenAI::Chat::ChatCompletion::Moderation::Input::Variants
-                ]
-              )
             end
+
+            sig { override.returns(T::Array[OpenAI::Chat::ChatCompletion::Moderation::Input::Variants]) }
             def self.variants
             end
+
           end
 
           # Moderation for the generated output.
           module Output
             extend OpenAI::Internal::Type::Union
 
-            Variants =
-              T.type_alias do
+            Variants = T.type_alias {
+              T.any(
+                OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults,
+                OpenAI::Chat::ChatCompletion::Moderation::Output::Error
+              )
+            }
+
+            class ModerationResults < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
                 T.any(
                   OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults,
-                  OpenAI::Chat::ChatCompletion::Moderation::Output::Error
+                  OpenAI::Internal::AnyHash
                 )
               end
 
-            class ModerationResults < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
-
               # The moderation model used to generate the results.
               sig { returns(String) }
               attr_accessor :model
 
               # A list of moderation results.
-              sig do
-                returns(
-                  T::Array[
-                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result
-                  ]
-                )
-              end
+              sig { returns(T::Array[OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result]) }
               attr_accessor :results
 
               # The object type, which is always `moderation_results`.
@@ -759,20 +728,25 @@ module OpenAI
               # Successful moderation results for the request input or generated output.
               sig do
                 params(
+
                   model: String,
-                  results:
-                    T::Array[
-                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::OrHash
-                    ],
+
+                  results: T::Array[OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::OrHash],
+
                   type: Symbol
-                ).returns(T.attached_class)
+                )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 # The moderation model used to generate the results.
                 model:,
+
                 # A list of moderation results.
                 results:,
+
                 # The object type, which is always `moderation_results`.
+
                 type: :moderation_results
               )
               end
@@ -781,10 +755,7 @@ module OpenAI
                 override.returns(
                   {
                     model: String,
-                    results:
-                      T::Array[
-                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result
-                      ],
+                    results: T::Array[OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result],
                     type: Symbol
                   }
                 )
@@ -793,13 +764,12 @@ module OpenAI
               end
 
               class Result < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # A dictionary of moderation categories to booleans, True if the input is flagged
                 # under this category.
@@ -807,7 +777,7 @@ module OpenAI
                 attr_accessor :categories
 
                 # Which modalities of input are reflected by the score for each category.
-                sig do
+                sig {
                   returns(
                     T::Hash[
                       Symbol,
@@ -816,7 +786,7 @@ module OpenAI
                       ]
                     ]
                   )
-                end
+                }
                 attr_accessor :category_applied_input_types
 
                 # A dictionary of moderation categories to scores.
@@ -839,34 +809,47 @@ module OpenAI
                 # A moderation result produced for the response input or output.
                 sig do
                   params(
+
                     categories: T::Hash[Symbol, T::Boolean],
-                    category_applied_input_types:
-                      T::Hash[
-                        Symbol,
-                        T::Array[
-                          OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
-                        ]
-                      ],
+
+                    category_applied_input_types: T::Hash[
+                      Symbol,
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
+                      ]
+                    ],
+
                     category_scores: T::Hash[Symbol, Float],
+
                     flagged: T::Boolean,
+
                     model: String,
+
                     type: Symbol
-                  ).returns(T.attached_class)
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # A dictionary of moderation categories to booleans, True if the input is flagged
                   # under this category.
                   categories:,
+
                   # Which modalities of input are reflected by the score for each category.
                   category_applied_input_types:,
+
                   # A dictionary of moderation categories to scores.
                   category_scores:,
+
                   # A boolean indicating whether the content was flagged by any category.
                   flagged:,
+
                   # The moderation model that produced this result.
                   model:,
+
                   # The object type, which was always `moderation_result` for successful moderation
                   # results.
+
                   type: :moderation_result
                 )
                 end
@@ -875,13 +858,12 @@ module OpenAI
                   override.returns(
                     {
                       categories: T::Hash[Symbol, T::Boolean],
-                      category_applied_input_types:
-                        T::Hash[
-                          Symbol,
-                          T::Array[
-                            OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                          ]
-                        ],
+                      category_applied_input_types: T::Hash[
+                        Symbol,
+                        T::Array[
+                          OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                        ]
+                      ],
                       category_scores: T::Hash[Symbol, Float],
                       flagged: T::Boolean,
                       model: String,
@@ -895,33 +877,30 @@ module OpenAI
                 module CategoryAppliedInputType
                   extend OpenAI::Internal::Type::Enum
 
-                  TaggedSymbol =
-                    T.type_alias do
-                      T.all(
-                        Symbol,
-                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType
-                      )
-                    end
+                  TaggedSymbol = T.type_alias {
+                    T.all(
+                      Symbol,
+                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType
+                    )
+                  }
                   OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                  TEXT =
-                    T.let(
-                      :text,
-                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
-                  IMAGE =
-                    T.let(
-                      :image,
-                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
+                  TEXT = T.let(
+                    :text,
+                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
+                  IMAGE = T.let(
+                    :image,
+                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
 
-                  sig do
+                  sig {
                     override.returns(
                       T::Array[
                         OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
                       ]
                     )
-                  end
+                  }
                   def self.values
                   end
                 end
@@ -929,13 +908,12 @@ module OpenAI
             end
 
             class Error < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletion::Moderation::Output::Error,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::Error,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               # The error code.
               sig { returns(String) }
@@ -951,38 +929,44 @@ module OpenAI
 
               # An error produced while attempting moderation.
               sig do
-                params(code: String, message: String, type: Symbol).returns(
-                  T.attached_class
+                params(
+
+                  code: String,
+
+                  message: String,
+
+                  type: Symbol
                 )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 # The error code.
                 code:,
+
                 # The error message.
                 message:,
+
                 # The object type, which is always `error`.
+
                 type: :error
               )
               end
 
               sig do
                 override.returns(
-                  { code: String, message: String, type: Symbol }
+                  {code: String, message: String, type: Symbol}
                 )
               end
               def to_hash
               end
-            end
 
-            sig do
-              override.returns(
-                T::Array[
-                  OpenAI::Chat::ChatCompletion::Moderation::Output::Variants
-                ]
-              )
             end
+
+            sig { override.returns(T::Array[OpenAI::Chat::ChatCompletion::Moderation::Output::Variants]) }
             def self.variants
             end
+
           end
         end
 
@@ -1009,52 +993,24 @@ module OpenAI
         module ServiceTier
           extend OpenAI::Internal::Type::Enum
 
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, OpenAI::Chat::ChatCompletion::ServiceTier)
-            end
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Chat::ChatCompletion::ServiceTier) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          AUTO =
-            T.let(
-              :auto,
-              OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-            )
-          DEFAULT =
-            T.let(
-              :default,
-              OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-            )
-          FLEX =
-            T.let(
-              :flex,
-              OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-            )
-          SCALE =
-            T.let(
-              :scale,
-              OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-            )
-          PRIORITY =
-            T.let(
-              :priority,
-              OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-            )
-          FAST =
-            T.let(
-              :fast,
-              OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
-            )
+          AUTO = T.let(:auto, OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
+          DEFAULT = T.let(:default, OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
+          FLEX = T.let(:flex, OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
+          SCALE = T.let(:scale, OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
+          PRIORITY = T.let(:priority, OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
+          FAST = T.let(:fast, OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol)
 
-          sig do
-            override.returns(
-              T::Array[OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol]) }
           def self.values
           end
         end
+
       end
+
     end
+
   end
 end