openai 0.80.0 → 0.82.0

data/rbi/openai/models/chat/chat_completion_chunk.rbi

@@ -2,14 +2,19 @@
 
 module OpenAI
   module Models
+
     ChatCompletionChunk = Chat::ChatCompletionChunk
 
     module Chat
+
       class ChatCompletionChunk < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(OpenAI::Chat::ChatCompletionChunk, OpenAI::Internal::AnyHash)
-          end
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Chat::ChatCompletionChunk,
+            OpenAI::Internal::AnyHash
+          )
+        end
 
         # A unique identifier for the chat completion. Each chunk has the same ID.
         sig { returns(String) }
@@ -36,19 +41,21 @@ module OpenAI
 
         # Moderation results for the request input and generated output. Present on the
         # moderation chunk when moderated completions are requested.
-        sig do
-          returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation))
-        end
+        sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation)) }
         attr_reader :moderation
 
-        sig do
-          params(
-            moderation:
-              T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation::OrHash)
-          ).void
-        end
+        sig { params(moderation: T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation::OrHash)).void }
         attr_writer :moderation
 
+        # An obfuscation string added to normalize the size of streamed chunks as a
+        # mitigation to certain side-channel attacks. The field is included by default and
+        # omitted when `stream_options.include_obfuscation` is `false`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :obfuscation
+
+        sig { params(obfuscation: String).void }
+        attr_writer :obfuscation
+
         # Specifies the processing type used for serving the request.
         #
         # - If set to 'auto', then the request will be processed with the service tier
@@ -69,13 +76,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::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)) }
         attr_accessor :service_tier
 
         # This fingerprint represents the backend configuration that the model runs with.
@@ -105,37 +106,55 @@ module OpenAI
         # [Learn more](https://platform.openai.com/docs/guides/streaming-responses).
         sig do
           params(
+
             id: String,
-            choices:
-              T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::OrHash],
+
+            choices: T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::OrHash],
+
             created: Integer,
+
             model: String,
-            moderation:
-              T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation::OrHash),
-            service_tier:
-              T.nilable(
-                OpenAI::Chat::ChatCompletionChunk::ServiceTier::OrSymbol
-              ),
+
+            moderation: T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation::OrHash),
+
+            obfuscation: String,
+
+            service_tier: T.nilable(OpenAI::Chat::ChatCompletionChunk::ServiceTier::OrSymbol),
+
             system_fingerprint: String,
+
             usage: T.nilable(OpenAI::CompletionUsage::OrHash),
+
             object: Symbol
-          ).returns(T.attached_class)
+          )
+            .returns(T.attached_class)
         end
         def self.new(
+
           # A unique identifier for the chat completion. Each chunk has the same ID.
           id:,
+
           # A list of chat completion choices. Can contain more than one elements if `n` is
           # greater than 1. Can also be empty for the last chunk if you set
           # `stream_options: {"include_usage": true}`.
           choices:,
+
           # The Unix timestamp (in seconds) of when the chat completion was created. Each
           # chunk has the same timestamp.
           created:,
+
           # The model to generate the completion.
           model:,
+
           # Moderation results for the request input and generated output. Present on the
           # moderation chunk when moderated completions are requested.
           moderation: nil,
+
+          # An obfuscation string added to normalize the size of streamed chunks as a
+          # mitigation to certain side-channel attacks. The field is included by default and
+          # omitted when `stream_options.include_obfuscation` is `false`.
+          obfuscation: nil,
+
           # Specifies the processing type used for serving the request.
           #
           # - If set to 'auto', then the request will be processed with the service tier
@@ -157,10 +176,12 @@ 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,
+
           # An optional field that will only be present when you set
           # `stream_options: {"include_usage": true}` in your request. When present, it
           # contains a null value **except for the last chunk** which contains the token
@@ -169,7 +190,9 @@ module OpenAI
           # **NOTE:** If the stream is interrupted or cancelled, you may not receive the
           # final usage chunk which contains the total token usage for the request.
           usage: nil,
+
           # The object type, which is always `chat.completion.chunk`.
+
           object: :"chat.completion.chunk"
         )
         end
@@ -182,12 +205,9 @@ module OpenAI
               created: Integer,
               model: String,
               object: Symbol,
-              moderation:
-                T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation),
-              service_tier:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-                ),
+              moderation: T.nilable(OpenAI::Chat::ChatCompletionChunk::Moderation),
+              obfuscation: String,
+              service_tier: T.nilable(OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol),
               system_fingerprint: String,
               usage: T.nilable(OpenAI::CompletionUsage)
             }
@@ -197,23 +217,18 @@ module OpenAI
         end
 
         class Choice < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Chat::ChatCompletionChunk::Choice,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Chat::ChatCompletionChunk::Choice,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # A chat completion delta generated by streamed model responses.
           sig { returns(OpenAI::Chat::ChatCompletionChunk::Choice::Delta) }
           attr_reader :delta
 
-          sig do
-            params(
-              delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::OrHash
-            ).void
-          end
+          sig { params(delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::OrHash).void }
           attr_writer :delta
 
           # The reason the model stopped generating tokens. This will be `stop` if the model
@@ -222,13 +237,7 @@ module OpenAI
           # content was omitted due to a flag from our content filters, `tool_calls` if the
           # model called a tool, or `function_call` (deprecated) if the model called a
           # function.
-          sig do
-            returns(
-              T.nilable(
-                OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-              )
-            )
-          end
+          sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol)) }
           attr_accessor :finish_reason
 
           # The index of the choice in the list of choices.
@@ -236,40 +245,30 @@ module OpenAI
           attr_accessor :index
 
           # Log probability information for the choice.
-          sig do
-            returns(
-              T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs)
-            )
-          end
+          sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs)) }
           attr_reader :logprobs
 
-          sig do
-            params(
-              logprobs:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs::OrHash
-                )
-            ).void
-          end
+          sig { params(logprobs: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs::OrHash)).void }
           attr_writer :logprobs
 
           sig do
             params(
+
               delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::OrHash,
-              finish_reason:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::OrSymbol
-                ),
+
+              finish_reason: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::OrSymbol),
+
               index: Integer,
-              logprobs:
-                T.nilable(
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs::OrHash
-                )
-            ).returns(T.attached_class)
+
+              logprobs: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs::OrHash)
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # A chat completion delta generated by streamed model responses.
             delta:,
+
             # 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
@@ -277,9 +276,12 @@ module OpenAI
             # model called a tool, or `function_call` (deprecated) if the model called a
             # function.
             finish_reason:,
+
             # The index of the choice in the list of choices.
             index:,
+
             # Log probability information for the choice.
+
             logprobs: nil
           )
           end
@@ -288,13 +290,9 @@ module OpenAI
             override.returns(
               {
                 delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta,
-                finish_reason:
-                  T.nilable(
-                    OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-                  ),
+                finish_reason: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol),
                 index: Integer,
-                logprobs:
-                  T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs)
+                logprobs: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs)
               }
             )
           end
@@ -302,13 +300,12 @@ module OpenAI
           end
 
           class Delta < OpenAI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta,
-                  OpenAI::Internal::AnyHash
-                )
-              end
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Chat::ChatCompletionChunk::Choice::Delta,
+                OpenAI::Internal::AnyHash
+              )
+            end
 
             # The contents of the chunk message.
             sig { returns(T.nilable(String)) }
@@ -316,21 +313,10 @@ module OpenAI
 
             # Deprecated and replaced by `tool_calls`. The name and arguments of a function
             # that should be called, as generated by the model.
-            sig do
-              returns(
-                T.nilable(
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall
-                )
-              )
-            end
+            sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall)) }
             attr_reader :function_call
 
-            sig do
-              params(
-                function_call:
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall::OrHash
-              ).void
-            end
+            sig { params(function_call: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall::OrHash).void }
             attr_writer :function_call
 
             # The refusal message generated by the model.
@@ -338,69 +324,51 @@ module OpenAI
             attr_accessor :refusal
 
             # The role of the author of this message.
-            sig do
-              returns(
-                T.nilable(
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                )
-              )
-            end
+            sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol)) }
             attr_reader :role
 
-            sig do
-              params(
-                role:
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::OrSymbol
-              ).void
-            end
+            sig { params(role: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::OrSymbol).void }
             attr_writer :role
 
-            sig do
-              returns(
-                T.nilable(
-                  T::Array[
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall
-                  ]
-                )
-              )
-            end
+            sig { returns(T.nilable(T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall])) }
             attr_reader :tool_calls
 
-            sig do
-              params(
-                tool_calls:
-                  T::Array[
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::OrHash
-                  ]
-              ).void
-            end
+            sig {
+              params(tool_calls: T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::OrHash]).void
+            }
             attr_writer :tool_calls
 
             # A chat completion delta generated by streamed model responses.
             sig do
               params(
+
                 content: T.nilable(String),
-                function_call:
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall::OrHash,
+
+                function_call: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall::OrHash,
+
                 refusal: T.nilable(String),
-                role:
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::OrSymbol,
-                tool_calls:
-                  T::Array[
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::OrHash
-                  ]
-              ).returns(T.attached_class)
+
+                role: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::OrSymbol,
+
+                tool_calls: T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::OrHash]
+              )
+                .returns(T.attached_class)
             end
             def self.new(
+
               # The contents of the chunk message.
               content: nil,
+
               # Deprecated and replaced by `tool_calls`. The name and arguments of a function
               # that should be called, as generated by the model.
               function_call: nil,
+
               # The refusal message generated by the model.
               refusal: nil,
+
               # The role of the author of this message.
               role: nil,
+
               tool_calls: nil
             )
             end
@@ -409,15 +377,10 @@ module OpenAI
               override.returns(
                 {
                   content: T.nilable(String),
-                  function_call:
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall,
+                  function_call: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall,
                   refusal: T.nilable(String),
-                  role:
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol,
-                  tool_calls:
-                    T::Array[
-                      OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall
-                    ]
+                  role: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol,
+                  tool_calls: T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall]
                 }
               )
             end
@@ -425,13 +388,12 @@ module OpenAI
             end
 
             class FunctionCall < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               # The arguments to call the function with, as generated by the model in JSON
               # format. Note that the model does not always generate valid JSON, and may
@@ -453,84 +415,63 @@ module OpenAI
               # Deprecated and replaced by `tool_calls`. The name and arguments of a function
               # that should be called, as generated by the model.
               sig do
-                params(arguments: String, name: String).returns(
-                  T.attached_class
+                params(
+
+                  arguments: String,
+
+                  name: String
                 )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 # The arguments to call the function with, as generated by the model in JSON
                 # format. Note that the model does not always generate valid JSON, and may
                 # hallucinate parameters not defined by your function schema. Validate the
                 # arguments in your code before calling your function.
                 arguments: nil,
+
                 # The name of the function to call.
+
                 name: nil
               )
               end
 
-              sig { override.returns({ arguments: String, name: String }) }
+              sig do
+                override.returns(
+                  {arguments: String, name: String}
+                )
+              end
               def to_hash
               end
+
             end
 
             # The role of the author of this message.
             module Role
               extend OpenAI::Internal::Type::Enum
 
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role
-                  )
-                end
+              TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role) }
               OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-              DEVELOPER =
-                T.let(
-                  :developer,
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                )
-              SYSTEM =
-                T.let(
-                  :system,
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                )
-              USER =
-                T.let(
-                  :user,
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                )
-              ASSISTANT =
-                T.let(
-                  :assistant,
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                )
-              TOOL =
-                T.let(
-                  :tool,
-                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                )
+              DEVELOPER = T.let(:developer, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol)
+              SYSTEM = T.let(:system, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol)
+              USER = T.let(:user, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol)
+              ASSISTANT = T.let(:assistant, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol)
+              TOOL = T.let(:tool, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol)
 
-              sig do
-                override.returns(
-                  T::Array[
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol
-                  ]
-                )
-              end
+              sig { override.returns(T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Role::TaggedSymbol]) }
               def self.values
               end
             end
 
             class ToolCall < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               sig { returns(Integer) }
               attr_accessor :index
@@ -542,57 +483,47 @@ module OpenAI
               sig { params(id: String).void }
               attr_writer :id
 
-              sig do
-                returns(
-                  T.nilable(
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function
-                  )
-                )
-              end
+              sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function)) }
               attr_reader :function
 
-              sig do
-                params(
-                  function:
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function::OrHash
-                ).void
-              end
+              sig {
+                params(function: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function::OrHash).void
+              }
               attr_writer :function
 
               # The type of the tool. Currently, only `function` is supported.
-              sig do
-                returns(
-                  T.nilable(
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol
-                  )
-                )
-              end
+              sig {
+                returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol))
+              }
               attr_reader :type
 
-              sig do
-                params(
-                  type:
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::OrSymbol
-                ).void
-              end
+              sig { params(type: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::OrSymbol).void }
               attr_writer :type
 
               sig do
                 params(
+
                   index: Integer,
+
                   id: String,
-                  function:
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function::OrHash,
-                  type:
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::OrSymbol
-                ).returns(T.attached_class)
+
+                  function: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function::OrHash,
+
+                  type: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::OrSymbol
+                )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 index:,
+
                 # The ID of the tool call.
                 id: nil,
+
                 function: nil,
+
                 # The type of the tool. Currently, only `function` is supported.
+
                 type: nil
               )
               end
@@ -602,10 +533,8 @@ module OpenAI
                   {
                     index: Integer,
                     id: String,
-                    function:
-                      OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function,
-                    type:
-                      OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol
+                    function: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function,
+                    type: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol
                   }
                 )
               end
@@ -613,13 +542,12 @@ module OpenAI
               end
 
               class Function < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Function,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # The arguments to call the function with, as generated by the model in JSON
                 # format. Note that the model does not always generate valid JSON, and may
@@ -639,52 +567,57 @@ module OpenAI
                 attr_writer :name
 
                 sig do
-                  params(arguments: String, name: String).returns(
-                    T.attached_class
+                  params(
+
+                    arguments: String,
+
+                    name: String
                   )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # The arguments to call the function with, as generated by the model in JSON
                   # format. Note that the model does not always generate valid JSON, and may
                   # hallucinate parameters not defined by your function schema. Validate the
                   # arguments in your code before calling your function.
                   arguments: nil,
+
                   # The name of the function to call.
+
                   name: nil
                 )
                 end
 
-                sig { override.returns({ arguments: String, name: String }) }
+                sig do
+                  override.returns(
+                    {arguments: String, name: String}
+                  )
+                end
                 def to_hash
                 end
+
               end
 
               # The type of the tool. Currently, only `function` is supported.
               module Type
                 extend OpenAI::Internal::Type::Enum
 
-                TaggedSymbol =
-                  T.type_alias do
-                    T.all(
-                      Symbol,
-                      OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type
-                    )
-                  end
+                TaggedSymbol = T.type_alias {
+                  T.all(Symbol, OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type)
+                }
                 OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                FUNCTION =
-                  T.let(
-                    :function,
-                    OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol
-                  )
+                FUNCTION = T.let(
+                  :function,
+                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol
+                )
 
-                sig do
+                sig {
                   override.returns(
-                    T::Array[
-                      OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol
-                    ]
+                    T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::Delta::ToolCall::Type::TaggedSymbol]
                   )
-                end
+                }
                 def self.values
                 end
               end
@@ -700,94 +633,56 @@ module OpenAI
           module FinishReason
             extend OpenAI::Internal::Type::Enum
 
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason
-                )
-              end
+            TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason) }
             OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-            STOP =
-              T.let(
-                :stop,
-                OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-              )
-            LENGTH =
-              T.let(
-                :length,
-                OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-              )
-            TOOL_CALLS =
-              T.let(
-                :tool_calls,
-                OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-              )
-            CONTENT_FILTER =
-              T.let(
-                :content_filter,
-                OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-              )
-            FUNCTION_CALL =
-              T.let(
-                :function_call,
-                OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-              )
+            STOP = T.let(:stop, OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol)
+            LENGTH = T.let(:length, OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol)
+            TOOL_CALLS = T.let(:tool_calls, OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol)
+            CONTENT_FILTER = T.let(
+              :content_filter,
+              OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
+            )
+            FUNCTION_CALL = T.let(:function_call, OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol)
 
-            sig do
-              override.returns(
-                T::Array[
-                  OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol
-                ]
-              )
-            end
+            sig { override.returns(T::Array[OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol]) }
             def self.values
             end
           end
 
           class Logprobs < OpenAI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  OpenAI::Chat::ChatCompletionChunk::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::ChatCompletionChunk::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
@@ -795,67 +690,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::ChatCompletionChunk::Moderation,
-                OpenAI::Internal::AnyHash
-              )
-            end
-
-          # Moderation for the request input.
-          sig do
-            returns(
-              OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Variants
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Chat::ChatCompletionChunk::Moderation,
+              OpenAI::Internal::AnyHash
             )
           end
+
+          # Moderation for the request input.
+          sig { returns(OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Variants) }
           attr_accessor :input
 
           # Moderation for the generated output.
-          sig do
-            returns(
-              OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Variants
-            )
-          end
+          sig { returns(OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Variants) }
           attr_accessor :output
 
           # Moderation results for the request input and generated output. Present on the
           # moderation chunk when moderated completions are requested.
           sig do
             params(
-              input:
-                T.any(
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::OrHash,
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Error::OrHash
-                ),
-              output:
-                T.any(
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::OrHash,
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Error::OrHash
-                )
-            ).returns(T.attached_class)
+
+              input: T.any(
+                OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::OrHash,
+                OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Error::OrHash
+              ),
+
+              output: T.any(
+                OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::OrHash,
+                OpenAI::Chat::ChatCompletionChunk::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
@@ -863,10 +748,8 @@ module OpenAI
           sig do
             override.returns(
               {
-                input:
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Variants,
-                output:
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Variants
+                input: OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Variants,
+                output: OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Variants
               }
             )
           end
@@ -877,35 +760,29 @@ module OpenAI
           module Input
             extend OpenAI::Internal::Type::Union
 
-            Variants =
-              T.type_alias do
+            Variants = T.type_alias {
+              T.any(
+                OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults,
+                OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Error
+              )
+            }
+
+            class ModerationResults < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
                 T.any(
                   OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults,
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Error
+                  OpenAI::Internal::AnyHash
                 )
               end
 
-            class ModerationResults < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletionChunk::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::ChatCompletionChunk::Moderation::Input::ModerationResults::Result
-                  ]
-                )
-              end
+              sig {
+                returns(T::Array[OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result])
+              }
               attr_accessor :results
 
               # The object type, which is always `moderation_results`.
@@ -915,20 +792,27 @@ module OpenAI
               # Successful moderation results for the request input or generated output.
               sig do
                 params(
+
                   model: String,
-                  results:
-                    T::Array[
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::OrHash
-                    ],
+
+                  results: T::Array[
+                    OpenAI::Chat::ChatCompletionChunk::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
@@ -937,10 +821,7 @@ module OpenAI
                 override.returns(
                   {
                     model: String,
-                    results:
-                      T::Array[
-                        OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result
-                      ],
+                    results: T::Array[OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result],
                     type: Symbol
                   }
                 )
@@ -949,13 +830,12 @@ module OpenAI
               end
 
               class Result < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # A dictionary of moderation categories to booleans, True if the input is flagged
                 # under this category.
@@ -963,7 +843,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,
@@ -972,7 +852,7 @@ module OpenAI
                       ]
                     ]
                   )
-                end
+                }
                 attr_accessor :category_applied_input_types
 
                 # A dictionary of moderation categories to scores.
@@ -995,34 +875,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::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
-                        ]
-                      ],
+
+                    category_applied_input_types: T::Hash[
+                      Symbol,
+                      T::Array[
+                        OpenAI::Chat::ChatCompletionChunk::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
@@ -1031,13 +924,12 @@ module OpenAI
                   override.returns(
                     {
                       categories: T::Hash[Symbol, T::Boolean],
-                      category_applied_input_types:
-                        T::Hash[
-                          Symbol,
-                          T::Array[
-                            OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                          ]
-                        ],
+                      category_applied_input_types: T::Hash[
+                        Symbol,
+                        T::Array[
+                          OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                        ]
+                      ],
                       category_scores: T::Hash[Symbol, Float],
                       flagged: T::Boolean,
                       model: String,
@@ -1051,33 +943,30 @@ module OpenAI
                 module CategoryAppliedInputType
                   extend OpenAI::Internal::Type::Enum
 
-                  TaggedSymbol =
-                    T.type_alias do
-                      T.all(
-                        Symbol,
-                        OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType
-                      )
-                    end
+                  TaggedSymbol = T.type_alias {
+                    T.all(
+                      Symbol,
+                      OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType
+                    )
+                  }
                   OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                  TEXT =
-                    T.let(
-                      :text,
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
-                  IMAGE =
-                    T.let(
-                      :image,
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
+                  TEXT = T.let(
+                    :text,
+                    OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
+                  IMAGE = T.let(
+                    :image,
+                    OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
 
-                  sig do
+                  sig {
                     override.returns(
                       T::Array[
                         OpenAI::Chat::ChatCompletionChunk::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
                       ]
                     )
-                  end
+                  }
                   def self.values
                   end
                 end
@@ -1085,13 +974,12 @@ module OpenAI
             end
 
             class Error < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Error,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletionChunk::Moderation::Input::Error,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               # The error code.
               sig { returns(String) }
@@ -1107,73 +995,73 @@ 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::ChatCompletionChunk::Moderation::Input::Variants
-                ]
-              )
             end
+
+            sig { override.returns(T::Array[OpenAI::Chat::ChatCompletionChunk::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::ChatCompletionChunk::Moderation::Output::ModerationResults,
+                OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Error
+              )
+            }
+
+            class ModerationResults < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
                 T.any(
                   OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults,
-                  OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Error
+                  OpenAI::Internal::AnyHash
                 )
               end
 
-            class ModerationResults < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletionChunk::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::ChatCompletionChunk::Moderation::Output::ModerationResults::Result
-                  ]
-                )
-              end
+              sig {
+                returns(T::Array[OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result])
+              }
               attr_accessor :results
 
               # The object type, which is always `moderation_results`.
@@ -1183,20 +1071,27 @@ module OpenAI
               # Successful moderation results for the request input or generated output.
               sig do
                 params(
+
                   model: String,
-                  results:
-                    T::Array[
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::OrHash
-                    ],
+
+                  results: T::Array[
+                    OpenAI::Chat::ChatCompletionChunk::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
@@ -1205,10 +1100,7 @@ module OpenAI
                 override.returns(
                   {
                     model: String,
-                    results:
-                      T::Array[
-                        OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result
-                      ],
+                    results: T::Array[OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result],
                     type: Symbol
                   }
                 )
@@ -1217,13 +1109,12 @@ module OpenAI
               end
 
               class Result < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # A dictionary of moderation categories to booleans, True if the input is flagged
                 # under this category.
@@ -1231,7 +1122,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,
@@ -1240,7 +1131,7 @@ module OpenAI
                       ]
                     ]
                   )
-                end
+                }
                 attr_accessor :category_applied_input_types
 
                 # A dictionary of moderation categories to scores.
@@ -1263,34 +1154,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::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
-                        ]
-                      ],
+
+                    category_applied_input_types: T::Hash[
+                      Symbol,
+                      T::Array[
+                        OpenAI::Chat::ChatCompletionChunk::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
@@ -1299,13 +1203,12 @@ module OpenAI
                   override.returns(
                     {
                       categories: T::Hash[Symbol, T::Boolean],
-                      category_applied_input_types:
-                        T::Hash[
-                          Symbol,
-                          T::Array[
-                            OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                          ]
-                        ],
+                      category_applied_input_types: T::Hash[
+                        Symbol,
+                        T::Array[
+                          OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                        ]
+                      ],
                       category_scores: T::Hash[Symbol, Float],
                       flagged: T::Boolean,
                       model: String,
@@ -1319,33 +1222,30 @@ module OpenAI
                 module CategoryAppliedInputType
                   extend OpenAI::Internal::Type::Enum
 
-                  TaggedSymbol =
-                    T.type_alias do
-                      T.all(
-                        Symbol,
-                        OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType
-                      )
-                    end
+                  TaggedSymbol = T.type_alias {
+                    T.all(
+                      Symbol,
+                      OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType
+                    )
+                  }
                   OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                  TEXT =
-                    T.let(
-                      :text,
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
-                  IMAGE =
-                    T.let(
-                      :image,
-                      OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
-                    )
+                  TEXT = T.let(
+                    :text,
+                    OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
+                  IMAGE = T.let(
+                    :image,
+                    OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                  )
 
-                  sig do
+                  sig {
                     override.returns(
                       T::Array[
                         OpenAI::Chat::ChatCompletionChunk::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
                       ]
                     )
-                  end
+                  }
                   def self.values
                   end
                 end
@@ -1353,13 +1253,12 @@ module OpenAI
             end
 
             class Error < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Error,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Error,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               # The error code.
               sig { returns(String) }
@@ -1375,38 +1274,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::ChatCompletionChunk::Moderation::Output::Variants
-                ]
-              )
             end
+
+            sig { override.returns(T::Array[OpenAI::Chat::ChatCompletionChunk::Moderation::Output::Variants]) }
             def self.variants
             end
+
           end
         end
 
@@ -1433,54 +1338,24 @@ module OpenAI
         module ServiceTier
           extend OpenAI::Internal::Type::Enum
 
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, OpenAI::Chat::ChatCompletionChunk::ServiceTier)
-            end
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Chat::ChatCompletionChunk::ServiceTier) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          AUTO =
-            T.let(
-              :auto,
-              OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
-          DEFAULT =
-            T.let(
-              :default,
-              OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
-          FLEX =
-            T.let(
-              :flex,
-              OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
-          SCALE =
-            T.let(
-              :scale,
-              OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
-          PRIORITY =
-            T.let(
-              :priority,
-              OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
-          FAST =
-            T.let(
-              :fast,
-              OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-            )
+          AUTO = T.let(:auto, OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)
+          DEFAULT = T.let(:default, OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)
+          FLEX = T.let(:flex, OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)
+          SCALE = T.let(:scale, OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)
+          PRIORITY = T.let(:priority, OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)
+          FAST = T.let(:fast, OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol)
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol
-              ]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Chat::ChatCompletionChunk::ServiceTier::TaggedSymbol]) }
           def self.values
           end
         end
+
       end
+
     end
+
   end
 end