chatcompletion.go

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

package omnistack

import (
	"context"
	"net/http"

	"github.com/stainless-sdks/omnistack-go/internal/apijson"
	"github.com/stainless-sdks/omnistack-go/internal/param"
	"github.com/stainless-sdks/omnistack-go/internal/requestconfig"
	"github.com/stainless-sdks/omnistack-go/option"
)

// ChatCompletionService contains methods and other services that help with
// interacting with the omnistack API.
//
// Note, unlike clients, this service does not read variables from the environment
// automatically. You should not instantiate this service directly, and instead use
// the [NewChatCompletionService] method instead.
type ChatCompletionService struct {
	Options []option.RequestOption
}

// NewChatCompletionService generates a new service that applies the given options
// to each request. These options are applied after the parent client's options (if
// there is one), and before any request-specific options.
func NewChatCompletionService(opts ...option.RequestOption) (r *ChatCompletionService) {
	r = &ChatCompletionService{}
	r.Options = opts
	return
}

// Creates a model response for the given chat conversation.
func (r *ChatCompletionService) New(ctx context.Context, body ChatCompletionNewParams, opts ...option.RequestOption) (res *ChatCompletionNewResponse, err error) {
	opts = append(r.Options[:], opts...)
	path := "chat/completions"
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
	return
}

// Represents a chat completion response returned by model, based on the provided
// input.
type ChatCompletionNewResponse struct {
	// A unique identifier for the chat completion.
	ID string `json:"id,required"`
	// A list of chat completion choices. Can be more than one if `n` is greater
	// than 1.
	Choices []ChatCompletionNewResponseChoice `json:"choices,required"`
	// The Unix timestamp (in seconds) of when the chat completion was created.
	Created int64 `json:"created,required"`
	// The model used for the chat completion.
	Model string `json:"model,required"`
	// The object type, which is always `chat.completion`.
	Object ChatCompletionNewResponseObject `json:"object,required"`
	// The service tier used for processing the request. This field is only included if
	// the `service_tier` parameter is specified in the request.
	ServiceTier ChatCompletionNewResponseServiceTier `json:"service_tier,nullable"`
	// 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.
	SystemFingerprint string `json:"system_fingerprint"`
	// Usage statistics for the completion request.
	Usage ChatCompletionNewResponseUsage `json:"usage"`
	JSON  chatCompletionNewResponseJSON  `json:"-"`
}

// chatCompletionNewResponseJSON contains the JSON metadata for the struct
// [ChatCompletionNewResponse]
type chatCompletionNewResponseJSON struct {
	ID                apijson.Field
	Choices           apijson.Field
	Created           apijson.Field
	Model             apijson.Field
	Object            apijson.Field
	ServiceTier       apijson.Field
	SystemFingerprint apijson.Field
	Usage             apijson.Field
	raw               string
	ExtraFields       map[string]apijson.Field
}

func (r *ChatCompletionNewResponse) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewResponseChoice struct {
	// 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
	// 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.
	FinishReason ChatCompletionNewResponseChoicesFinishReason `json:"finish_reason,required"`
	// The index of the choice in the list of choices.
	Index int64 `json:"index,required"`
	// Log probability information for the choice.
	Logprobs ChatCompletionNewResponseChoicesLogprobs `json:"logprobs,required,nullable"`
	// A chat completion message generated by the model.
	Message ChatCompletionNewResponseChoicesMessage `json:"message,required"`
	JSON    chatCompletionNewResponseChoiceJSON     `json:"-"`
}

// chatCompletionNewResponseChoiceJSON contains the JSON metadata for the struct
// [ChatCompletionNewResponseChoice]
type chatCompletionNewResponseChoiceJSON struct {
	FinishReason apijson.Field
	Index        apijson.Field
	Logprobs     apijson.Field
	Message      apijson.Field
	raw          string
	ExtraFields  map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoice) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoiceJSON) RawJSON() string {
	return r.raw
}

// 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
// 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.
type ChatCompletionNewResponseChoicesFinishReason string

const (
	ChatCompletionNewResponseChoicesFinishReasonStop          ChatCompletionNewResponseChoicesFinishReason = "stop"
	ChatCompletionNewResponseChoicesFinishReasonLength        ChatCompletionNewResponseChoicesFinishReason = "length"
	ChatCompletionNewResponseChoicesFinishReasonToolCalls     ChatCompletionNewResponseChoicesFinishReason = "tool_calls"
	ChatCompletionNewResponseChoicesFinishReasonContentFilter ChatCompletionNewResponseChoicesFinishReason = "content_filter"
	ChatCompletionNewResponseChoicesFinishReasonFunctionCall  ChatCompletionNewResponseChoicesFinishReason = "function_call"
)

func (r ChatCompletionNewResponseChoicesFinishReason) IsKnown() bool {
	switch r {
	case ChatCompletionNewResponseChoicesFinishReasonStop, ChatCompletionNewResponseChoicesFinishReasonLength, ChatCompletionNewResponseChoicesFinishReasonToolCalls, ChatCompletionNewResponseChoicesFinishReasonContentFilter, ChatCompletionNewResponseChoicesFinishReasonFunctionCall:
		return true
	}
	return false
}

// Log probability information for the choice.
type ChatCompletionNewResponseChoicesLogprobs struct {
	// A list of message content tokens with log probability information.
	Content []ChatCompletionNewResponseChoicesLogprobsContent `json:"content,required,nullable"`
	// A list of message refusal tokens with log probability information.
	Refusal []ChatCompletionNewResponseChoicesLogprobsRefusal `json:"refusal,required,nullable"`
	JSON    chatCompletionNewResponseChoicesLogprobsJSON      `json:"-"`
}

// chatCompletionNewResponseChoicesLogprobsJSON contains the JSON metadata for the
// struct [ChatCompletionNewResponseChoicesLogprobs]
type chatCompletionNewResponseChoicesLogprobsJSON struct {
	Content     apijson.Field
	Refusal     apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesLogprobs) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesLogprobsJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewResponseChoicesLogprobsContent struct {
	// The token.
	Token string `json:"token,required"`
	// A list of integers representing the UTF-8 bytes representation of the token.
	// Useful in instances where characters are represented by multiple tokens and
	// their byte representations must be combined to generate the correct text
	// representation. Can be `null` if there is no bytes representation for the token.
	Bytes []int64 `json:"bytes,required,nullable"`
	// The log probability of this token, if it is within the top 20 most likely
	// tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
	// unlikely.
	Logprob float64 `json:"logprob,required"`
	// List of the most likely tokens and their log probability, at this token
	// position. In rare cases, there may be fewer than the number of requested
	// `top_logprobs` returned.
	TopLogprobs []ChatCompletionNewResponseChoicesLogprobsContentTopLogprob `json:"top_logprobs,required"`
	JSON        chatCompletionNewResponseChoicesLogprobsContentJSON         `json:"-"`
}

// chatCompletionNewResponseChoicesLogprobsContentJSON contains the JSON metadata
// for the struct [ChatCompletionNewResponseChoicesLogprobsContent]
type chatCompletionNewResponseChoicesLogprobsContentJSON struct {
	Token       apijson.Field
	Bytes       apijson.Field
	Logprob     apijson.Field
	TopLogprobs apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesLogprobsContent) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesLogprobsContentJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewResponseChoicesLogprobsContentTopLogprob struct {
	// The token.
	Token string `json:"token,required"`
	// A list of integers representing the UTF-8 bytes representation of the token.
	// Useful in instances where characters are represented by multiple tokens and
	// their byte representations must be combined to generate the correct text
	// representation. Can be `null` if there is no bytes representation for the token.
	Bytes []int64 `json:"bytes,required,nullable"`
	// The log probability of this token, if it is within the top 20 most likely
	// tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
	// unlikely.
	Logprob float64                                                       `json:"logprob,required"`
	JSON    chatCompletionNewResponseChoicesLogprobsContentTopLogprobJSON `json:"-"`
}

// chatCompletionNewResponseChoicesLogprobsContentTopLogprobJSON contains the JSON
// metadata for the struct
// [ChatCompletionNewResponseChoicesLogprobsContentTopLogprob]
type chatCompletionNewResponseChoicesLogprobsContentTopLogprobJSON struct {
	Token       apijson.Field
	Bytes       apijson.Field
	Logprob     apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesLogprobsContentTopLogprob) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesLogprobsContentTopLogprobJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewResponseChoicesLogprobsRefusal struct {
	// The token.
	Token string `json:"token,required"`
	// A list of integers representing the UTF-8 bytes representation of the token.
	// Useful in instances where characters are represented by multiple tokens and
	// their byte representations must be combined to generate the correct text
	// representation. Can be `null` if there is no bytes representation for the token.
	Bytes []int64 `json:"bytes,required,nullable"`
	// The log probability of this token, if it is within the top 20 most likely
	// tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
	// unlikely.
	Logprob float64 `json:"logprob,required"`
	// List of the most likely tokens and their log probability, at this token
	// position. In rare cases, there may be fewer than the number of requested
	// `top_logprobs` returned.
	TopLogprobs []ChatCompletionNewResponseChoicesLogprobsRefusalTopLogprob `json:"top_logprobs,required"`
	JSON        chatCompletionNewResponseChoicesLogprobsRefusalJSON         `json:"-"`
}

// chatCompletionNewResponseChoicesLogprobsRefusalJSON contains the JSON metadata
// for the struct [ChatCompletionNewResponseChoicesLogprobsRefusal]
type chatCompletionNewResponseChoicesLogprobsRefusalJSON struct {
	Token       apijson.Field
	Bytes       apijson.Field
	Logprob     apijson.Field
	TopLogprobs apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesLogprobsRefusal) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesLogprobsRefusalJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewResponseChoicesLogprobsRefusalTopLogprob struct {
	// The token.
	Token string `json:"token,required"`
	// A list of integers representing the UTF-8 bytes representation of the token.
	// Useful in instances where characters are represented by multiple tokens and
	// their byte representations must be combined to generate the correct text
	// representation. Can be `null` if there is no bytes representation for the token.
	Bytes []int64 `json:"bytes,required,nullable"`
	// The log probability of this token, if it is within the top 20 most likely
	// tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
	// unlikely.
	Logprob float64                                                       `json:"logprob,required"`
	JSON    chatCompletionNewResponseChoicesLogprobsRefusalTopLogprobJSON `json:"-"`
}

// chatCompletionNewResponseChoicesLogprobsRefusalTopLogprobJSON contains the JSON
// metadata for the struct
// [ChatCompletionNewResponseChoicesLogprobsRefusalTopLogprob]
type chatCompletionNewResponseChoicesLogprobsRefusalTopLogprobJSON struct {
	Token       apijson.Field
	Bytes       apijson.Field
	Logprob     apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesLogprobsRefusalTopLogprob) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesLogprobsRefusalTopLogprobJSON) RawJSON() string {
	return r.raw
}

// A chat completion message generated by the model.
type ChatCompletionNewResponseChoicesMessage struct {
	// The contents of the message.
	Content string `json:"content,required,nullable"`
	// The refusal message generated by the model.
	Refusal string `json:"refusal,required,nullable"`
	// The role of the author of this message.
	Role ChatCompletionNewResponseChoicesMessageRole `json:"role,required"`
	// Deprecated and replaced by `tool_calls`. The name and arguments of a function
	// that should be called, as generated by the model.
	FunctionCall ChatCompletionNewResponseChoicesMessageFunctionCall `json:"function_call"`
	// The tool calls generated by the model, such as function calls.
	ToolCalls []ChatCompletionNewResponseChoicesMessageToolCall `json:"tool_calls"`
	JSON      chatCompletionNewResponseChoicesMessageJSON       `json:"-"`
}

// chatCompletionNewResponseChoicesMessageJSON contains the JSON metadata for the
// struct [ChatCompletionNewResponseChoicesMessage]
type chatCompletionNewResponseChoicesMessageJSON struct {
	Content      apijson.Field
	Refusal      apijson.Field
	Role         apijson.Field
	FunctionCall apijson.Field
	ToolCalls    apijson.Field
	raw          string
	ExtraFields  map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesMessage) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesMessageJSON) RawJSON() string {
	return r.raw
}

// The role of the author of this message.
type ChatCompletionNewResponseChoicesMessageRole string

const (
	ChatCompletionNewResponseChoicesMessageRoleAssistant ChatCompletionNewResponseChoicesMessageRole = "assistant"
)

func (r ChatCompletionNewResponseChoicesMessageRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewResponseChoicesMessageRoleAssistant:
		return true
	}
	return false
}

// Deprecated and replaced by `tool_calls`. The name and arguments of a function
// that should be called, as generated by the model.
type ChatCompletionNewResponseChoicesMessageFunctionCall struct {
	// 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 string `json:"arguments,required"`
	// The name of the function to call.
	Name string                                                  `json:"name,required"`
	JSON chatCompletionNewResponseChoicesMessageFunctionCallJSON `json:"-"`
}

// chatCompletionNewResponseChoicesMessageFunctionCallJSON contains the JSON
// metadata for the struct [ChatCompletionNewResponseChoicesMessageFunctionCall]
type chatCompletionNewResponseChoicesMessageFunctionCallJSON struct {
	Arguments   apijson.Field
	Name        apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesMessageFunctionCall) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesMessageFunctionCallJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewResponseChoicesMessageToolCall struct {
	// The ID of the tool call.
	ID string `json:"id,required"`
	// The function that the model called.
	Function ChatCompletionNewResponseChoicesMessageToolCallsFunction `json:"function,required"`
	// The type of the tool. Currently, only `function` is supported.
	Type ChatCompletionNewResponseChoicesMessageToolCallsType `json:"type,required"`
	JSON chatCompletionNewResponseChoicesMessageToolCallJSON  `json:"-"`
}

// chatCompletionNewResponseChoicesMessageToolCallJSON contains the JSON metadata
// for the struct [ChatCompletionNewResponseChoicesMessageToolCall]
type chatCompletionNewResponseChoicesMessageToolCallJSON struct {
	ID          apijson.Field
	Function    apijson.Field
	Type        apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesMessageToolCall) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesMessageToolCallJSON) RawJSON() string {
	return r.raw
}

// The function that the model called.
type ChatCompletionNewResponseChoicesMessageToolCallsFunction struct {
	// 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 string `json:"arguments,required"`
	// The name of the function to call.
	Name string                                                       `json:"name,required"`
	JSON chatCompletionNewResponseChoicesMessageToolCallsFunctionJSON `json:"-"`
}

// chatCompletionNewResponseChoicesMessageToolCallsFunctionJSON contains the JSON
// metadata for the struct
// [ChatCompletionNewResponseChoicesMessageToolCallsFunction]
type chatCompletionNewResponseChoicesMessageToolCallsFunctionJSON struct {
	Arguments   apijson.Field
	Name        apijson.Field
	raw         string
	ExtraFields map[string]apijson.Field
}

func (r *ChatCompletionNewResponseChoicesMessageToolCallsFunction) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseChoicesMessageToolCallsFunctionJSON) RawJSON() string {
	return r.raw
}

// The type of the tool. Currently, only `function` is supported.
type ChatCompletionNewResponseChoicesMessageToolCallsType string

const (
	ChatCompletionNewResponseChoicesMessageToolCallsTypeFunction ChatCompletionNewResponseChoicesMessageToolCallsType = "function"
)

func (r ChatCompletionNewResponseChoicesMessageToolCallsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewResponseChoicesMessageToolCallsTypeFunction:
		return true
	}
	return false
}

// The object type, which is always `chat.completion`.
type ChatCompletionNewResponseObject string

const (
	ChatCompletionNewResponseObjectChatCompletion ChatCompletionNewResponseObject = "chat.completion"
)

func (r ChatCompletionNewResponseObject) IsKnown() bool {
	switch r {
	case ChatCompletionNewResponseObjectChatCompletion:
		return true
	}
	return false
}

// The service tier used for processing the request. This field is only included if
// the `service_tier` parameter is specified in the request.
type ChatCompletionNewResponseServiceTier string

const (
	ChatCompletionNewResponseServiceTierScale   ChatCompletionNewResponseServiceTier = "scale"
	ChatCompletionNewResponseServiceTierDefault ChatCompletionNewResponseServiceTier = "default"
)

func (r ChatCompletionNewResponseServiceTier) IsKnown() bool {
	switch r {
	case ChatCompletionNewResponseServiceTierScale, ChatCompletionNewResponseServiceTierDefault:
		return true
	}
	return false
}

// Usage statistics for the completion request.
type ChatCompletionNewResponseUsage struct {
	// Number of tokens in the generated completion.
	CompletionTokens int64 `json:"completion_tokens,required"`
	// Number of tokens in the prompt.
	PromptTokens int64 `json:"prompt_tokens,required"`
	// Total number of tokens used in the request (prompt + completion).
	TotalTokens int64 `json:"total_tokens,required"`
	// Breakdown of tokens used in a completion.
	CompletionTokensDetails ChatCompletionNewResponseUsageCompletionTokensDetails `json:"completion_tokens_details"`
	JSON                    chatCompletionNewResponseUsageJSON                    `json:"-"`
}

// chatCompletionNewResponseUsageJSON contains the JSON metadata for the struct
// [ChatCompletionNewResponseUsage]
type chatCompletionNewResponseUsageJSON struct {
	CompletionTokens        apijson.Field
	PromptTokens            apijson.Field
	TotalTokens             apijson.Field
	CompletionTokensDetails apijson.Field
	raw                     string
	ExtraFields             map[string]apijson.Field
}

func (r *ChatCompletionNewResponseUsage) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseUsageJSON) RawJSON() string {
	return r.raw
}

// Breakdown of tokens used in a completion.
type ChatCompletionNewResponseUsageCompletionTokensDetails struct {
	// Tokens generated by the model for reasoning.
	ReasoningTokens int64                                                     `json:"reasoning_tokens"`
	JSON            chatCompletionNewResponseUsageCompletionTokensDetailsJSON `json:"-"`
}

// chatCompletionNewResponseUsageCompletionTokensDetailsJSON contains the JSON
// metadata for the struct [ChatCompletionNewResponseUsageCompletionTokensDetails]
type chatCompletionNewResponseUsageCompletionTokensDetailsJSON struct {
	ReasoningTokens apijson.Field
	raw             string
	ExtraFields     map[string]apijson.Field
}

func (r *ChatCompletionNewResponseUsageCompletionTokensDetails) UnmarshalJSON(data []byte) (err error) {
	return apijson.UnmarshalRoot(data, r)
}

func (r chatCompletionNewResponseUsageCompletionTokensDetailsJSON) RawJSON() string {
	return r.raw
}

type ChatCompletionNewParams struct {
	// A list of messages comprising the conversation so far.
	// [Example Python code](https://cookbook.openai.com/examples/how_to_format_inputs_to_chatgpt_models).
	Messages param.Field[[]ChatCompletionNewParamsMessageUnion] `json:"messages,required"`
	// ID of the model to use. See the
	// [model endpoint compatibility](/docs/models/model-endpoint-compatibility) table
	// for details on which models work with the Chat API.
	Model param.Field[ChatCompletionNewParamsModel] `json:"model,required"`
	// Number between -2.0 and 2.0. Positive values penalize new tokens based on their
	// existing frequency in the text so far, decreasing the model's likelihood to
	// repeat the same line verbatim.
	//
	// [See more information about frequency and presence penalties.](/docs/guides/text-generation/parameter-details)
	FrequencyPenalty param.Field[float64] `json:"frequency_penalty"`
	// Deprecated in favor of `tool_choice`.
	//
	// Controls which (if any) function is called by the model. `none` means the model
	// will not call a function and instead generates a message. `auto` means the model
	// can pick between generating a message or calling a function. Specifying a
	// particular function via `{"name": "my_function"}` forces the model to call that
	// function.
	//
	// `none` is the default when no functions are present. `auto` is the default if
	// functions are present.
	FunctionCall param.Field[ChatCompletionNewParamsFunctionCallUnion] `json:"function_call"`
	// Deprecated in favor of `tools`.
	//
	// A list of functions the model may generate JSON inputs for.
	Functions param.Field[[]ChatCompletionNewParamsFunction] `json:"functions"`
	// Modify the likelihood of specified tokens appearing in the completion.
	//
	// Accepts a JSON object that maps tokens (specified by their token ID in the
	// tokenizer) to an associated bias value from -100 to 100. Mathematically, the
	// bias is added to the logits generated by the model prior to sampling. The exact
	// effect will vary per model, but values between -1 and 1 should decrease or
	// increase likelihood of selection; values like -100 or 100 should result in a ban
	// or exclusive selection of the relevant token.
	LogitBias param.Field[map[string]int64] `json:"logit_bias"`
	// Whether to return log probabilities of the output tokens or not. If true,
	// returns the log probabilities of each output token returned in the `content` of
	// `message`.
	Logprobs param.Field[bool] `json:"logprobs"`
	// An upper bound for the number of tokens that can be generated for a completion,
	// including visible output tokens and [reasoning tokens](/docs/guides/reasoning).
	MaxCompletionTokens param.Field[int64] `json:"max_completion_tokens"`
	// The maximum number of [tokens](/tokenizer) that can be generated in the chat
	// completion. This value can be used to control
	// [costs](https://openai.com/api/pricing/) for text generated via API.
	//
	// This value is now deprecated in favor of `max_completion_tokens`, and is not
	// compatible with [o1 series models](/docs/guides/reasoning).
	MaxTokens param.Field[int64] `json:"max_tokens"`
	// How many chat completion choices to generate for each input message. Note that
	// you will be charged based on the number of generated tokens across all of the
	// choices. Keep `n` as `1` to minimize costs.
	N param.Field[int64] `json:"n"`
	// Whether to enable
	// [parallel function calling](/docs/guides/function-calling/parallel-function-calling)
	// during tool use.
	ParallelToolCalls param.Field[bool] `json:"parallel_tool_calls"`
	// Number between -2.0 and 2.0. Positive values penalize new tokens based on
	// whether they appear in the text so far, increasing the model's likelihood to
	// talk about new topics.
	//
	// [See more information about frequency and presence penalties.](/docs/guides/text-generation/parameter-details)
	PresencePenalty param.Field[float64] `json:"presence_penalty"`
	// An object specifying the format that the model must output. Compatible with
	// [GPT-4o](/docs/models/gpt-4o), [GPT-4o mini](/docs/models/gpt-4o-mini),
	// [GPT-4 Turbo](/docs/models/gpt-4-and-gpt-4-turbo) and all GPT-3.5 Turbo models
	// newer than `gpt-3.5-turbo-1106`.
	//
	// Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
	// Outputs which ensures the model will match your supplied JSON schema. Learn more
	// in the [Structured Outputs guide](/docs/guides/structured-outputs).
	//
	// Setting to `{ "type": "json_object" }` enables JSON mode, which ensures the
	// message the model generates is valid JSON.
	//
	// **Important:** when using JSON mode, you **must** also instruct the model to
	// produce JSON yourself via a system or user message. Without this, the model may
	// generate an unending stream of whitespace until the generation reaches the token
	// limit, resulting in a long-running and seemingly "stuck" request. Also note that
	// the message content may be partially cut off if `finish_reason="length"`, which
	// indicates the generation exceeded `max_tokens` or the conversation exceeded the
	// max context length.
	ResponseFormat param.Field[ChatCompletionNewParamsResponseFormatUnion] `json:"response_format"`
	// This feature is in Beta. If specified, our system will make a best effort to
	// sample deterministically, such that repeated requests with the same `seed` and
	// parameters should return the same result. Determinism is not guaranteed, and you
	// should refer to the `system_fingerprint` response parameter to monitor changes
	// in the backend.
	Seed param.Field[int64] `json:"seed"`
	// Specifies the latency tier to use for processing the request. This parameter is
	// relevant for customers subscribed to the scale tier service:
	//
	//   - If set to 'auto', and the Project is Scale tier enabled, the system will
	//     utilize scale tier credits until they are exhausted.
	//   - If set to 'auto', and the Project is not Scale tier enabled, the request will
	//     be processed using the default service tier with a lower uptime SLA and no
	//     latency guarentee.
	//   - If set to 'default', the request will be processed using the default service
	//     tier with a lower uptime SLA and no latency guarentee.
	//   - When not set, the default behavior is 'auto'.
	//
	// When this parameter is set, the response body will include the `service_tier`
	// utilized.
	ServiceTier param.Field[ChatCompletionNewParamsServiceTier] `json:"service_tier"`
	// Up to 4 sequences where the API will stop generating further tokens.
	Stop param.Field[ChatCompletionNewParamsStopUnion] `json:"stop"`
	// If set, partial message deltas will be sent, like in ChatGPT. Tokens will be
	// sent as data-only
	// [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
	// as they become available, with the stream terminated by a `data: [DONE]`
	// message.
	// [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions).
	Stream param.Field[bool] `json:"stream"`
	// Options for streaming response. Only set this when you set `stream: true`.
	StreamOptions param.Field[ChatCompletionNewParamsStreamOptions] `json:"stream_options"`
	// What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
	// make the output more random, while lower values like 0.2 will make it more
	// focused and deterministic.
	//
	// We generally recommend altering this or `top_p` but not both.
	Temperature param.Field[float64] `json:"temperature"`
	// Controls which (if any) tool is called by the model. `none` means the model will
	// not call any tool and instead generates a message. `auto` means the model can
	// pick between generating a message or calling one or more tools. `required` means
	// the model must call one or more tools. Specifying a particular tool via
	// `{"type": "function", "function": {"name": "my_function"}}` forces the model to
	// call that tool.
	//
	// `none` is the default when no tools are present. `auto` is the default if tools
	// are present.
	ToolChoice param.Field[ChatCompletionNewParamsToolChoiceUnion] `json:"tool_choice"`
	// A list of tools the model may call. Currently, only functions are supported as a
	// tool. Use this to provide a list of functions the model may generate JSON inputs
	// for. A max of 128 functions are supported.
	Tools param.Field[[]ChatCompletionNewParamsTool] `json:"tools"`
	// An integer between 0 and 20 specifying the number of most likely tokens to
	// return at each token position, each with an associated log probability.
	// `logprobs` must be set to `true` if this parameter is used.
	TopLogprobs param.Field[int64] `json:"top_logprobs"`
	// An alternative to sampling with temperature, called nucleus sampling, where the
	// model considers the results of the tokens with top_p probability mass. So 0.1
	// means only the tokens comprising the top 10% probability mass are considered.
	//
	// We generally recommend altering this or `temperature` but not both.
	TopP param.Field[float64] `json:"top_p"`
	// A unique identifier representing your end-user, which can help OpenAI to monitor
	// and detect abuse. [Learn more](/docs/guides/safety-best-practices/end-user-ids).
	User param.Field[string] `json:"user"`
}

func (r ChatCompletionNewParams) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

type ChatCompletionNewParamsMessage struct {
	Content param.Field[interface{}] `json:"content,required"`
	// The role of the messages author, in this case `system`.
	Role param.Field[ChatCompletionNewParamsMessagesRole] `json:"role,required"`
	// An optional name for the participant. Provides the model information to
	// differentiate between participants of the same role.
	Name param.Field[string] `json:"name"`
	// The refusal message by the assistant.
	Refusal      param.Field[string]      `json:"refusal"`
	ToolCalls    param.Field[interface{}] `json:"tool_calls,required"`
	FunctionCall param.Field[interface{}] `json:"function_call,required"`
	// Tool call that this message is responding to.
	ToolCallID param.Field[string] `json:"tool_call_id"`
}

func (r ChatCompletionNewParamsMessage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessage) implementsChatCompletionNewParamsMessageUnion() {}

// Satisfied by
// [ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessage],
// [ChatCompletionNewParamsMessagesChatCompletionRequestUserMessage],
// [ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessage],
// [ChatCompletionNewParamsMessagesChatCompletionRequestToolMessage],
// [ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessage],
// [ChatCompletionNewParamsMessage].
type ChatCompletionNewParamsMessageUnion interface {
	implementsChatCompletionNewParamsMessageUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessage struct {
	// The contents of the system message.
	Content param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentUnion] `json:"content,required"`
	// The role of the messages author, in this case `system`.
	Role param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageRole] `json:"role,required"`
	// An optional name for the participant. Provides the model information to
	// differentiate between participants of the same role.
	Name param.Field[string] `json:"name"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessage) implementsChatCompletionNewParamsMessageUnion() {
}

// The contents of the system message.
//
// Satisfied by [shared.UnionString],
// [ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentParts].
type ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentUnion interface {
	ImplementsChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentParts []ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPart

func (r ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentParts) ImplementsChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentUnion() {
}

type ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPart struct {
	// The text content.
	Text param.Field[string] `json:"text,required"`
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPartsType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPart) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPartsType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPartsTypeText ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPartsType = "text"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPartsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageContentArrayOfContentPartsTypeText:
		return true
	}
	return false
}

// The role of the messages author, in this case `system`.
type ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageRole string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageRoleSystem ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageRole = "system"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestSystemMessageRoleSystem:
		return true
	}
	return false
}

type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessage struct {
	// The contents of the user message.
	Content param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentUnion] `json:"content,required"`
	// The role of the messages author, in this case `user`.
	Role param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageRole] `json:"role,required"`
	// An optional name for the participant. Provides the model information to
	// differentiate between participants of the same role.
	Name param.Field[string] `json:"name"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessage) implementsChatCompletionNewParamsMessageUnion() {
}

// The contents of the user message.
//
// Satisfied by [shared.UnionString],
// [ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentParts].
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentUnion interface {
	ImplementsChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentParts []ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartUnion

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentParts) ImplementsChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentUnion() {
}

type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPart struct {
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsType] `json:"type,required"`
	// The text content.
	Text     param.Field[string]      `json:"text"`
	ImageURL param.Field[interface{}] `json:"image_url,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPart) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPart) implementsChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartUnion() {
}

// Satisfied by
// [ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText],
// [ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImage],
// [ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPart].
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartUnion interface {
	implementsChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText struct {
	// The text content.
	Text param.Field[string] `json:"text,required"`
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText) implementsChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartUnion() {
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextTypeText ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType = "text"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextTypeText:
		return true
	}
	return false
}

type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImage struct {
	ImageURL param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURL] `json:"image_url,required"`
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImage) implementsChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartUnion() {
}

type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURL struct {
	// Either a URL of the image or the base64 encoded image data.
	URL param.Field[string] `json:"url,required" format:"uri"`
	// Specifies the detail level of the image. Learn more in the
	// [Vision guide](/docs/guides/vision/low-or-high-fidelity-image-understanding).
	Detail param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetail] `json:"detail"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURL) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// Specifies the detail level of the image. Learn more in the
// [Vision guide](/docs/guides/vision/low-or-high-fidelity-image-understanding).
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetail string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetailAuto ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetail = "auto"
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetailLow  ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetail = "low"
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetailHigh ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetail = "high"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetail) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetailAuto, ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetailLow, ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageImageURLDetailHigh:
		return true
	}
	return false
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageTypeImageURL ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageType = "image_url"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartImageTypeImageURL:
		return true
	}
	return false
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsTypeText     ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsType = "text"
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsTypeImageURL ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsType = "image_url"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsTypeText, ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageContentArrayOfContentPartsTypeImageURL:
		return true
	}
	return false
}

// The role of the messages author, in this case `user`.
type ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageRole string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageRoleUser ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageRole = "user"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestUserMessageRoleUser:
		return true
	}
	return false
}

type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessage struct {
	// The role of the messages author, in this case `assistant`.
	Role param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageRole] `json:"role,required"`
	// The contents of the assistant message. Required unless `tool_calls` or
	// `function_call` is specified.
	Content param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentUnion] `json:"content"`
	// Deprecated and replaced by `tool_calls`. The name and arguments of a function
	// that should be called, as generated by the model.
	FunctionCall param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageFunctionCall] `json:"function_call"`
	// An optional name for the participant. Provides the model information to
	// differentiate between participants of the same role.
	Name param.Field[string] `json:"name"`
	// The refusal message by the assistant.
	Refusal param.Field[string] `json:"refusal"`
	// The tool calls generated by the model, such as function calls.
	ToolCalls param.Field[[]ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCall] `json:"tool_calls"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessage) implementsChatCompletionNewParamsMessageUnion() {
}

// The role of the messages author, in this case `assistant`.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageRole string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageRoleAssistant ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageRole = "assistant"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageRoleAssistant:
		return true
	}
	return false
}

// The contents of the assistant message. Required unless `tool_calls` or
// `function_call` is specified.
//
// Satisfied by [shared.UnionString],
// [ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentParts].
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentUnion interface {
	ImplementsChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentParts []ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartUnion

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentParts) ImplementsChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentUnion() {
}

type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPart struct {
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsType] `json:"type,required"`
	// The text content.
	Text param.Field[string] `json:"text"`
	// The refusal message generated by the model.
	Refusal param.Field[string] `json:"refusal"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPart) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPart) implementsChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartUnion() {
}

// Satisfied by
// [ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText],
// [ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusal],
// [ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPart].
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartUnion interface {
	implementsChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText struct {
	// The text content.
	Text param.Field[string] `json:"text,required"`
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartText) implementsChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartUnion() {
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextTypeText ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType = "text"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartTextTypeText:
		return true
	}
	return false
}

type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusal struct {
	// The refusal message generated by the model.
	Refusal param.Field[string] `json:"refusal,required"`
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusalType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusal) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusal) implementsChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartUnion() {
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusalType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusalTypeRefusal ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusalType = "refusal"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusalType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsChatCompletionRequestMessageContentPartRefusalTypeRefusal:
		return true
	}
	return false
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsTypeText    ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsType = "text"
	ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsTypeRefusal ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsType = "refusal"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsTypeText, ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageContentArrayOfContentPartsTypeRefusal:
		return true
	}
	return false
}

// Deprecated and replaced by `tool_calls`. The name and arguments of a function
// that should be called, as generated by the model.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageFunctionCall struct {
	// 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 param.Field[string] `json:"arguments,required"`
	// The name of the function to call.
	Name param.Field[string] `json:"name,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageFunctionCall) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCall struct {
	// The ID of the tool call.
	ID param.Field[string] `json:"id,required"`
	// The function that the model called.
	Function param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsFunction] `json:"function,required"`
	// The type of the tool. Currently, only `function` is supported.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCall) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The function that the model called.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsFunction struct {
	// 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 param.Field[string] `json:"arguments,required"`
	// The name of the function to call.
	Name param.Field[string] `json:"name,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsFunction) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The type of the tool. Currently, only `function` is supported.
type ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsTypeFunction ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsType = "function"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestAssistantMessageToolCallsTypeFunction:
		return true
	}
	return false
}

type ChatCompletionNewParamsMessagesChatCompletionRequestToolMessage struct {
	// The contents of the tool message.
	Content param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentUnion] `json:"content,required"`
	// The role of the messages author, in this case `tool`.
	Role param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageRole] `json:"role,required"`
	// Tool call that this message is responding to.
	ToolCallID param.Field[string] `json:"tool_call_id,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestToolMessage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestToolMessage) implementsChatCompletionNewParamsMessageUnion() {
}

// The contents of the tool message.
//
// Satisfied by [shared.UnionString],
// [ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentParts].
type ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentUnion interface {
	ImplementsChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentUnion()
}

type ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentParts []ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPart

func (r ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentParts) ImplementsChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentUnion() {
}

type ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPart struct {
	// The text content.
	Text param.Field[string] `json:"text,required"`
	// The type of the content part.
	Type param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPartsType] `json:"type,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPart) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The type of the content part.
type ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPartsType string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPartsTypeText ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPartsType = "text"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPartsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageContentArrayOfContentPartsTypeText:
		return true
	}
	return false
}

// The role of the messages author, in this case `tool`.
type ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageRole string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageRoleTool ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageRole = "tool"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestToolMessageRoleTool:
		return true
	}
	return false
}

type ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessage struct {
	// The contents of the function message.
	Content param.Field[string] `json:"content,required"`
	// The name of the function to call.
	Name param.Field[string] `json:"name,required"`
	// The role of the messages author, in this case `function`.
	Role param.Field[ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessageRole] `json:"role,required"`
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessage) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessage) implementsChatCompletionNewParamsMessageUnion() {
}

// The role of the messages author, in this case `function`.
type ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessageRole string

const (
	ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessageRoleFunction ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessageRole = "function"
)

func (r ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessageRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesChatCompletionRequestFunctionMessageRoleFunction:
		return true
	}
	return false
}

// The role of the messages author, in this case `system`.
type ChatCompletionNewParamsMessagesRole string

const (
	ChatCompletionNewParamsMessagesRoleSystem    ChatCompletionNewParamsMessagesRole = "system"
	ChatCompletionNewParamsMessagesRoleUser      ChatCompletionNewParamsMessagesRole = "user"
	ChatCompletionNewParamsMessagesRoleAssistant ChatCompletionNewParamsMessagesRole = "assistant"
	ChatCompletionNewParamsMessagesRoleTool      ChatCompletionNewParamsMessagesRole = "tool"
	ChatCompletionNewParamsMessagesRoleFunction  ChatCompletionNewParamsMessagesRole = "function"
)

func (r ChatCompletionNewParamsMessagesRole) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsMessagesRoleSystem, ChatCompletionNewParamsMessagesRoleUser, ChatCompletionNewParamsMessagesRoleAssistant, ChatCompletionNewParamsMessagesRoleTool, ChatCompletionNewParamsMessagesRoleFunction:
		return true
	}
	return false
}

type ChatCompletionNewParamsModel string

const (
	ChatCompletionNewParamsModelO1Preview           ChatCompletionNewParamsModel = "o1-preview"
	ChatCompletionNewParamsModelO1Preview2024_09_12 ChatCompletionNewParamsModel = "o1-preview-2024-09-12"
	ChatCompletionNewParamsModelO1Mini              ChatCompletionNewParamsModel = "o1-mini"
	ChatCompletionNewParamsModelO1Mini2024_09_12    ChatCompletionNewParamsModel = "o1-mini-2024-09-12"
	ChatCompletionNewParamsModelGpt4o               ChatCompletionNewParamsModel = "gpt-4o"
	ChatCompletionNewParamsModelGpt4o2024_08_06     ChatCompletionNewParamsModel = "gpt-4o-2024-08-06"
	ChatCompletionNewParamsModelGpt4o2024_05_13     ChatCompletionNewParamsModel = "gpt-4o-2024-05-13"
	ChatCompletionNewParamsModelChatgpt4oLatest     ChatCompletionNewParamsModel = "chatgpt-4o-latest"
	ChatCompletionNewParamsModelGpt4oMini           ChatCompletionNewParamsModel = "gpt-4o-mini"
	ChatCompletionNewParamsModelGpt4oMini2024_07_18 ChatCompletionNewParamsModel = "gpt-4o-mini-2024-07-18"
	ChatCompletionNewParamsModelGpt4Turbo           ChatCompletionNewParamsModel = "gpt-4-turbo"
	ChatCompletionNewParamsModelGpt4Turbo2024_04_09 ChatCompletionNewParamsModel = "gpt-4-turbo-2024-04-09"
	ChatCompletionNewParamsModelGpt4_0125Preview    ChatCompletionNewParamsModel = "gpt-4-0125-preview"
	ChatCompletionNewParamsModelGpt4TurboPreview    ChatCompletionNewParamsModel = "gpt-4-turbo-preview"
	ChatCompletionNewParamsModelGpt4_1106Preview    ChatCompletionNewParamsModel = "gpt-4-1106-preview"
	ChatCompletionNewParamsModelGpt4VisionPreview   ChatCompletionNewParamsModel = "gpt-4-vision-preview"
	ChatCompletionNewParamsModelGpt4                ChatCompletionNewParamsModel = "gpt-4"
	ChatCompletionNewParamsModelGpt4_0314           ChatCompletionNewParamsModel = "gpt-4-0314"
	ChatCompletionNewParamsModelGpt4_0613           ChatCompletionNewParamsModel = "gpt-4-0613"
	ChatCompletionNewParamsModelGpt4_32k            ChatCompletionNewParamsModel = "gpt-4-32k"
	ChatCompletionNewParamsModelGpt4_32k0314        ChatCompletionNewParamsModel = "gpt-4-32k-0314"
	ChatCompletionNewParamsModelGpt4_32k0613        ChatCompletionNewParamsModel = "gpt-4-32k-0613"
	ChatCompletionNewParamsModelGpt3_5Turbo         ChatCompletionNewParamsModel = "gpt-3.5-turbo"
	ChatCompletionNewParamsModelGpt3_5Turbo16k      ChatCompletionNewParamsModel = "gpt-3.5-turbo-16k"
	ChatCompletionNewParamsModelGpt3_5Turbo0301     ChatCompletionNewParamsModel = "gpt-3.5-turbo-0301"
	ChatCompletionNewParamsModelGpt3_5Turbo0613     ChatCompletionNewParamsModel = "gpt-3.5-turbo-0613"
	ChatCompletionNewParamsModelGpt3_5Turbo1106     ChatCompletionNewParamsModel = "gpt-3.5-turbo-1106"
	ChatCompletionNewParamsModelGpt3_5Turbo0125     ChatCompletionNewParamsModel = "gpt-3.5-turbo-0125"
	ChatCompletionNewParamsModelGpt3_5Turbo16k0613  ChatCompletionNewParamsModel = "gpt-3.5-turbo-16k-0613"
)

func (r ChatCompletionNewParamsModel) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsModelO1Preview, ChatCompletionNewParamsModelO1Preview2024_09_12, ChatCompletionNewParamsModelO1Mini, ChatCompletionNewParamsModelO1Mini2024_09_12, ChatCompletionNewParamsModelGpt4o, ChatCompletionNewParamsModelGpt4o2024_08_06, ChatCompletionNewParamsModelGpt4o2024_05_13, ChatCompletionNewParamsModelChatgpt4oLatest, ChatCompletionNewParamsModelGpt4oMini, ChatCompletionNewParamsModelGpt4oMini2024_07_18, ChatCompletionNewParamsModelGpt4Turbo, ChatCompletionNewParamsModelGpt4Turbo2024_04_09, ChatCompletionNewParamsModelGpt4_0125Preview, ChatCompletionNewParamsModelGpt4TurboPreview, ChatCompletionNewParamsModelGpt4_1106Preview, ChatCompletionNewParamsModelGpt4VisionPreview, ChatCompletionNewParamsModelGpt4, ChatCompletionNewParamsModelGpt4_0314, ChatCompletionNewParamsModelGpt4_0613, ChatCompletionNewParamsModelGpt4_32k, ChatCompletionNewParamsModelGpt4_32k0314, ChatCompletionNewParamsModelGpt4_32k0613, ChatCompletionNewParamsModelGpt3_5Turbo, ChatCompletionNewParamsModelGpt3_5Turbo16k, ChatCompletionNewParamsModelGpt3_5Turbo0301, ChatCompletionNewParamsModelGpt3_5Turbo0613, ChatCompletionNewParamsModelGpt3_5Turbo1106, ChatCompletionNewParamsModelGpt3_5Turbo0125, ChatCompletionNewParamsModelGpt3_5Turbo16k0613:
		return true
	}
	return false
}

// Deprecated in favor of `tool_choice`.
//
// Controls which (if any) function is called by the model. `none` means the model
// will not call a function and instead generates a message. `auto` means the model
// can pick between generating a message or calling a function. Specifying a
// particular function via `{"name": "my_function"}` forces the model to call that
// function.
//
// `none` is the default when no functions are present. `auto` is the default if
// functions are present.
//
// Satisfied by [ChatCompletionNewParamsFunctionCallString],
// [ChatCompletionNewParamsFunctionCallChatCompletionFunctionCallOption].
type ChatCompletionNewParamsFunctionCallUnion interface {
	implementsChatCompletionNewParamsFunctionCallUnion()
}

// `none` means the model will not call a function and instead generates a message.
// `auto` means the model can pick between generating a message or calling a
// function.
type ChatCompletionNewParamsFunctionCallString string

const (
	ChatCompletionNewParamsFunctionCallStringNone ChatCompletionNewParamsFunctionCallString = "none"
	ChatCompletionNewParamsFunctionCallStringAuto ChatCompletionNewParamsFunctionCallString = "auto"
)

func (r ChatCompletionNewParamsFunctionCallString) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsFunctionCallStringNone, ChatCompletionNewParamsFunctionCallStringAuto:
		return true
	}
	return false
}

func (r ChatCompletionNewParamsFunctionCallString) implementsChatCompletionNewParamsFunctionCallUnion() {
}

// Specifying a particular function via `{"name": "my_function"}` forces the model
// to call that function.
type ChatCompletionNewParamsFunctionCallChatCompletionFunctionCallOption struct {
	// The name of the function to call.
	Name param.Field[string] `json:"name,required"`
}

func (r ChatCompletionNewParamsFunctionCallChatCompletionFunctionCallOption) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsFunctionCallChatCompletionFunctionCallOption) implementsChatCompletionNewParamsFunctionCallUnion() {
}

type ChatCompletionNewParamsFunction struct {
	// The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
	// underscores and dashes, with a maximum length of 64.
	Name param.Field[string] `json:"name,required"`
	// A description of what the function does, used by the model to choose when and
	// how to call the function.
	Description param.Field[string] `json:"description"`
	// The parameters the functions accepts, described as a JSON Schema object. See the
	// [guide](/docs/guides/function-calling) for examples, and the
	// [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
	// documentation about the format.
	//
	// Omitting `parameters` defines a function with an empty parameter list.
	Parameters param.Field[map[string]interface{}] `json:"parameters"`
}

func (r ChatCompletionNewParamsFunction) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// An object specifying the format that the model must output. Compatible with
// [GPT-4o](/docs/models/gpt-4o), [GPT-4o mini](/docs/models/gpt-4o-mini),
// [GPT-4 Turbo](/docs/models/gpt-4-and-gpt-4-turbo) and all GPT-3.5 Turbo models
// newer than `gpt-3.5-turbo-1106`.
//
// Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
// Outputs which ensures the model will match your supplied JSON schema. Learn more
// in the [Structured Outputs guide](/docs/guides/structured-outputs).
//
// Setting to `{ "type": "json_object" }` enables JSON mode, which ensures the
// message the model generates is valid JSON.
//
// **Important:** when using JSON mode, you **must** also instruct the model to
// produce JSON yourself via a system or user message. Without this, the model may
// generate an unending stream of whitespace until the generation reaches the token
// limit, resulting in a long-running and seemingly "stuck" request. Also note that
// the message content may be partially cut off if `finish_reason="length"`, which
// indicates the generation exceeded `max_tokens` or the conversation exceeded the
// max context length.
type ChatCompletionNewParamsResponseFormat struct {
	// The type of response format being defined: `text`
	Type       param.Field[ChatCompletionNewParamsResponseFormatType] `json:"type,required"`
	JsonSchema param.Field[interface{}]                               `json:"json_schema,required"`
}

func (r ChatCompletionNewParamsResponseFormat) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsResponseFormat) implementsChatCompletionNewParamsResponseFormatUnion() {
}

// An object specifying the format that the model must output. Compatible with
// [GPT-4o](/docs/models/gpt-4o), [GPT-4o mini](/docs/models/gpt-4o-mini),
// [GPT-4 Turbo](/docs/models/gpt-4-and-gpt-4-turbo) and all GPT-3.5 Turbo models
// newer than `gpt-3.5-turbo-1106`.
//
// Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
// Outputs which ensures the model will match your supplied JSON schema. Learn more
// in the [Structured Outputs guide](/docs/guides/structured-outputs).
//
// Setting to `{ "type": "json_object" }` enables JSON mode, which ensures the
// message the model generates is valid JSON.
//
// **Important:** when using JSON mode, you **must** also instruct the model to
// produce JSON yourself via a system or user message. Without this, the model may
// generate an unending stream of whitespace until the generation reaches the token
// limit, resulting in a long-running and seemingly "stuck" request. Also note that
// the message content may be partially cut off if `finish_reason="length"`, which
// indicates the generation exceeded `max_tokens` or the conversation exceeded the
// max context length.
//
// Satisfied by [ChatCompletionNewParamsResponseFormatResponseFormatText],
// [ChatCompletionNewParamsResponseFormatResponseFormatJsonObject],
// [ChatCompletionNewParamsResponseFormatResponseFormatJsonSchema],
// [ChatCompletionNewParamsResponseFormat].
type ChatCompletionNewParamsResponseFormatUnion interface {
	implementsChatCompletionNewParamsResponseFormatUnion()
}

type ChatCompletionNewParamsResponseFormatResponseFormatText struct {
	// The type of response format being defined: `text`
	Type param.Field[ChatCompletionNewParamsResponseFormatResponseFormatTextType] `json:"type,required"`
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatText) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatText) implementsChatCompletionNewParamsResponseFormatUnion() {
}

// The type of response format being defined: `text`
type ChatCompletionNewParamsResponseFormatResponseFormatTextType string

const (
	ChatCompletionNewParamsResponseFormatResponseFormatTextTypeText ChatCompletionNewParamsResponseFormatResponseFormatTextType = "text"
)

func (r ChatCompletionNewParamsResponseFormatResponseFormatTextType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsResponseFormatResponseFormatTextTypeText:
		return true
	}
	return false
}

type ChatCompletionNewParamsResponseFormatResponseFormatJsonObject struct {
	// The type of response format being defined: `json_object`
	Type param.Field[ChatCompletionNewParamsResponseFormatResponseFormatJsonObjectType] `json:"type,required"`
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonObject) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonObject) implementsChatCompletionNewParamsResponseFormatUnion() {
}

// The type of response format being defined: `json_object`
type ChatCompletionNewParamsResponseFormatResponseFormatJsonObjectType string

const (
	ChatCompletionNewParamsResponseFormatResponseFormatJsonObjectTypeJsonObject ChatCompletionNewParamsResponseFormatResponseFormatJsonObjectType = "json_object"
)

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonObjectType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsResponseFormatResponseFormatJsonObjectTypeJsonObject:
		return true
	}
	return false
}

type ChatCompletionNewParamsResponseFormatResponseFormatJsonSchema struct {
	JsonSchema param.Field[ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaJsonSchema] `json:"json_schema,required"`
	// The type of response format being defined: `json_schema`
	Type param.Field[ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaType] `json:"type,required"`
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonSchema) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonSchema) implementsChatCompletionNewParamsResponseFormatUnion() {
}

type ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaJsonSchema struct {
	// The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores
	// and dashes, with a maximum length of 64.
	Name param.Field[string] `json:"name,required"`
	// A description of what the response format is for, used by the model to determine
	// how to respond in the format.
	Description param.Field[string] `json:"description"`
	// The schema for the response format, described as a JSON Schema object.
	Schema param.Field[map[string]interface{}] `json:"schema"`
	// Whether to enable strict schema adherence when generating the output. If set to
	// true, the model will always follow the exact schema defined in the `schema`
	// field. Only a subset of JSON Schema is supported when `strict` is `true`. To
	// learn more, read the
	// [Structured Outputs guide](/docs/guides/structured-outputs).
	Strict param.Field[bool] `json:"strict"`
}

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaJsonSchema) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The type of response format being defined: `json_schema`
type ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaType string

const (
	ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaTypeJsonSchema ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaType = "json_schema"
)

func (r ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsResponseFormatResponseFormatJsonSchemaTypeJsonSchema:
		return true
	}
	return false
}

// The type of response format being defined: `text`
type ChatCompletionNewParamsResponseFormatType string

const (
	ChatCompletionNewParamsResponseFormatTypeText       ChatCompletionNewParamsResponseFormatType = "text"
	ChatCompletionNewParamsResponseFormatTypeJsonObject ChatCompletionNewParamsResponseFormatType = "json_object"
	ChatCompletionNewParamsResponseFormatTypeJsonSchema ChatCompletionNewParamsResponseFormatType = "json_schema"
)

func (r ChatCompletionNewParamsResponseFormatType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsResponseFormatTypeText, ChatCompletionNewParamsResponseFormatTypeJsonObject, ChatCompletionNewParamsResponseFormatTypeJsonSchema:
		return true
	}
	return false
}

// Specifies the latency tier to use for processing the request. This parameter is
// relevant for customers subscribed to the scale tier service:
//
//   - If set to 'auto', and the Project is Scale tier enabled, the system will
//     utilize scale tier credits until they are exhausted.
//   - If set to 'auto', and the Project is not Scale tier enabled, the request will
//     be processed using the default service tier with a lower uptime SLA and no
//     latency guarentee.
//   - If set to 'default', the request will be processed using the default service
//     tier with a lower uptime SLA and no latency guarentee.
//   - When not set, the default behavior is 'auto'.
//
// When this parameter is set, the response body will include the `service_tier`
// utilized.
type ChatCompletionNewParamsServiceTier string

const (
	ChatCompletionNewParamsServiceTierAuto    ChatCompletionNewParamsServiceTier = "auto"
	ChatCompletionNewParamsServiceTierDefault ChatCompletionNewParamsServiceTier = "default"
)

func (r ChatCompletionNewParamsServiceTier) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsServiceTierAuto, ChatCompletionNewParamsServiceTierDefault:
		return true
	}
	return false
}

// Up to 4 sequences where the API will stop generating further tokens.
//
// Satisfied by [shared.UnionString], [ChatCompletionNewParamsStopArray].
type ChatCompletionNewParamsStopUnion interface {
	ImplementsChatCompletionNewParamsStopUnion()
}

type ChatCompletionNewParamsStopArray []string

func (r ChatCompletionNewParamsStopArray) ImplementsChatCompletionNewParamsStopUnion() {}

// Options for streaming response. Only set this when you set `stream: true`.
type ChatCompletionNewParamsStreamOptions struct {
	// If set, an additional chunk will be streamed before the `data: [DONE]` message.
	// The `usage` field on this chunk shows the token usage statistics for the entire
	// request, and the `choices` field will always be an empty array. All other chunks
	// will also include a `usage` field, but with a null value.
	IncludeUsage param.Field[bool] `json:"include_usage"`
}

func (r ChatCompletionNewParamsStreamOptions) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// Controls which (if any) tool is called by the model. `none` means the model will
// not call any tool and instead generates a message. `auto` means the model can
// pick between generating a message or calling one or more tools. `required` means
// the model must call one or more tools. Specifying a particular tool via
// `{"type": "function", "function": {"name": "my_function"}}` forces the model to
// call that tool.
//
// `none` is the default when no tools are present. `auto` is the default if tools
// are present.
//
// Satisfied by [ChatCompletionNewParamsToolChoiceString],
// [ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoice].
type ChatCompletionNewParamsToolChoiceUnion interface {
	implementsChatCompletionNewParamsToolChoiceUnion()
}

// `none` means the model will not call any tool and instead generates a message.
// `auto` means the model can pick between generating a message or calling one or
// more tools. `required` means the model must call one or more tools.
type ChatCompletionNewParamsToolChoiceString string

const (
	ChatCompletionNewParamsToolChoiceStringNone     ChatCompletionNewParamsToolChoiceString = "none"
	ChatCompletionNewParamsToolChoiceStringAuto     ChatCompletionNewParamsToolChoiceString = "auto"
	ChatCompletionNewParamsToolChoiceStringRequired ChatCompletionNewParamsToolChoiceString = "required"
)

func (r ChatCompletionNewParamsToolChoiceString) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsToolChoiceStringNone, ChatCompletionNewParamsToolChoiceStringAuto, ChatCompletionNewParamsToolChoiceStringRequired:
		return true
	}
	return false
}

func (r ChatCompletionNewParamsToolChoiceString) implementsChatCompletionNewParamsToolChoiceUnion() {}

// Specifies a tool the model should use. Use to force the model to call a specific
// function.
type ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoice struct {
	Function param.Field[ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceFunction] `json:"function,required"`
	// The type of the tool. Currently, only `function` is supported.
	Type param.Field[ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceType] `json:"type,required"`
}

func (r ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoice) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

func (r ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoice) implementsChatCompletionNewParamsToolChoiceUnion() {
}

type ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceFunction struct {
	// The name of the function to call.
	Name param.Field[string] `json:"name,required"`
}

func (r ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceFunction) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The type of the tool. Currently, only `function` is supported.
type ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceType string

const (
	ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceTypeFunction ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceType = "function"
)

func (r ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsToolChoiceChatCompletionNamedToolChoiceTypeFunction:
		return true
	}
	return false
}

type ChatCompletionNewParamsTool struct {
	Function param.Field[ChatCompletionNewParamsToolsFunction] `json:"function,required"`
	// The type of the tool. Currently, only `function` is supported.
	Type param.Field[ChatCompletionNewParamsToolsType] `json:"type,required"`
}

func (r ChatCompletionNewParamsTool) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

type ChatCompletionNewParamsToolsFunction struct {
	// The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
	// underscores and dashes, with a maximum length of 64.
	Name param.Field[string] `json:"name,required"`
	// A description of what the function does, used by the model to choose when and
	// how to call the function.
	Description param.Field[string] `json:"description"`
	// The parameters the functions accepts, described as a JSON Schema object. See the
	// [guide](/docs/guides/function-calling) for examples, and the
	// [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
	// documentation about the format.
	//
	// Omitting `parameters` defines a function with an empty parameter list.
	Parameters param.Field[map[string]interface{}] `json:"parameters"`
	// Whether to enable strict schema adherence when generating the function call. If
	// set to true, the model will follow the exact schema defined in the `parameters`
	// field. Only a subset of JSON Schema is supported when `strict` is `true`. Learn
	// more about Structured Outputs in the
	// [function calling guide](docs/guides/function-calling).
	Strict param.Field[bool] `json:"strict"`
}

func (r ChatCompletionNewParamsToolsFunction) MarshalJSON() (data []byte, err error) {
	return apijson.MarshalRoot(r)
}

// The type of the tool. Currently, only `function` is supported.
type ChatCompletionNewParamsToolsType string

const (
	ChatCompletionNewParamsToolsTypeFunction ChatCompletionNewParamsToolsType = "function"
)

func (r ChatCompletionNewParamsToolsType) IsKnown() bool {
	switch r {
	case ChatCompletionNewParamsToolsTypeFunction:
		return true
	}
	return false
}