@effect/ai-openai 0.11.0 → 0.11.2

package/src/Generated.ts

@@ -9,24 +9,34 @@ import * as Effect from "effect/Effect"
 import type { ParseError } from "effect/ParseResult"
 import * as S from "effect/Schema"
 
+export class ListAssistantsParamsOrder extends S.Literal("asc", "desc") {}
+
 export class ListAssistantsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListAssistantsParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class AssistantObjectObject extends S.Literal("assistant") {}
+
+export class AssistantToolsCodeType extends S.Literal("code_interpreter") {}
+
 export class AssistantToolsCode extends S.Struct({
-  "type": S.Literal("code_interpreter")
+  "type": AssistantToolsCodeType
 }) {}
 
+export class AssistantToolsFileSearchType extends S.Literal("file_search") {}
+
+export class FileSearchRankingOptionsRanker extends S.Literal("auto", "default_2024_08_21") {}
+
 export class FileSearchRankingOptions extends S.Struct({
-  "ranker": S.optionalWith(S.Literal("auto", "default_2024_08_21"), { nullable: true }),
+  "ranker": S.optionalWith(FileSearchRankingOptionsRanker, { nullable: true }),
   "score_threshold": S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1))
 }) {}
 
 export class AssistantToolsFileSearch extends S.Struct({
-  "type": S.Literal("file_search"),
+  "type": AssistantToolsFileSearchType,
   "file_search": S.optionalWith(
     S.Struct({
       "max_num_results": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
@@ -38,6 +48,8 @@ export class AssistantToolsFileSearch extends S.Struct({
   )
 }) {}
 
+export class AssistantToolsFunctionType extends S.Literal("function") {}
+
 export class FunctionParameters extends S.Record({ key: S.String, value: S.Unknown }) {}
 
 export class FunctionObject extends S.Struct({
@@ -48,22 +60,28 @@ export class FunctionObject extends S.Struct({
 }) {}
 
 export class AssistantToolsFunction extends S.Struct({
-  "type": S.Literal("function"),
+  "type": AssistantToolsFunctionType,
   "function": FunctionObject
 }) {}
 
+export class ResponseFormatTextType extends S.Literal("text") {}
+
 export class ResponseFormatText extends S.Struct({
-  "type": S.Literal("text")
+  "type": ResponseFormatTextType
 }) {}
 
+export class ResponseFormatJsonObjectType extends S.Literal("json_object") {}
+
 export class ResponseFormatJsonObject extends S.Struct({
-  "type": S.Literal("json_object")
+  "type": ResponseFormatJsonObjectType
 }) {}
 
+export class ResponseFormatJsonSchemaType extends S.Literal("json_schema") {}
+
 export class ResponseFormatJsonSchemaSchema extends S.Record({ key: S.String, value: S.Unknown }) {}
 
 export class ResponseFormatJsonSchema extends S.Struct({
-  "type": S.Literal("json_schema"),
+  "type": ResponseFormatJsonSchemaType,
   "json_schema": S.Struct({
     "description": S.optionalWith(S.String, { nullable: true }),
     "name": S.String,
@@ -78,7 +96,7 @@ export class AssistantsApiResponseFormatOption
 
 export class AssistantObject extends S.Struct({
   "id": S.String,
-  "object": S.Literal("assistant"),
+  "object": AssistantObjectObject,
   "created_at": S.Int,
   "name": S.NullOr(S.String.pipe(S.maxLength(256))),
   "description": S.NullOr(S.String.pipe(S.maxLength(512))),
@@ -126,36 +144,39 @@ export class ListAssistantsResponse extends S.Class<ListAssistantsResponse>("Lis
   "has_more": S.Boolean
 }) {}
 
+export class CreateAssistantRequestModel extends S.Literal(
+  "gpt-4o",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-0125-preview",
+  "gpt-4-turbo-preview",
+  "gpt-4-1106-preview",
+  "gpt-4-vision-preview",
+  "gpt-4",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-1106",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo-16k-0613"
+) {}
+
+export class CreateAssistantRequestToolResourcesFileSearchVectorStoresChunkingStrategyType
+  extends S.Literal("static")
+{}
+
 export class CreateAssistantRequest extends S.Class<CreateAssistantRequest>("CreateAssistantRequest")({
-  "model": S.Union(
-    S.String,
-    S.Literal(
-      "gpt-4o",
-      "gpt-4o-2024-08-06",
-      "gpt-4o-2024-05-13",
-      "gpt-4o-2024-08-06",
-      "gpt-4o-mini",
-      "gpt-4o-mini-2024-07-18",
-      "gpt-4-turbo",
-      "gpt-4-turbo-2024-04-09",
-      "gpt-4-0125-preview",
-      "gpt-4-turbo-preview",
-      "gpt-4-1106-preview",
-      "gpt-4-vision-preview",
-      "gpt-4",
-      "gpt-4-0314",
-      "gpt-4-0613",
-      "gpt-4-32k",
-      "gpt-4-32k-0314",
-      "gpt-4-32k-0613",
-      "gpt-3.5-turbo",
-      "gpt-3.5-turbo-16k",
-      "gpt-3.5-turbo-0613",
-      "gpt-3.5-turbo-1106",
-      "gpt-3.5-turbo-0125",
-      "gpt-3.5-turbo-16k-0613"
-    )
-  ),
+  "model": S.Union(S.String, CreateAssistantRequestModel),
   "name": S.optionalWith(S.String.pipe(S.maxLength(256)), { nullable: true }),
   "description": S.optionalWith(S.String.pipe(S.maxLength(512)), { nullable: true }),
   "instructions": S.optionalWith(S.String.pipe(S.maxLength(256000)), { nullable: true }),
@@ -250,17 +271,27 @@ export class ModifyAssistantRequest extends S.Class<ModifyAssistantRequest>("Mod
   "response_format": S.optionalWith(AssistantsApiResponseFormatOption, { nullable: true })
 }) {}
 
+export class DeleteAssistantResponseObject extends S.Literal("assistant.deleted") {}
+
 export class DeleteAssistantResponse extends S.Class<DeleteAssistantResponse>("DeleteAssistantResponse")({
   "id": S.String,
   "deleted": S.Boolean,
-  "object": S.Literal("assistant.deleted")
+  "object": DeleteAssistantResponseObject
 }) {}
 
+export class CreateSpeechRequestModel extends S.Literal("tts-1", "tts-1-hd") {}
+
+export class CreateSpeechRequestVoice
+  extends S.Literal("alloy", "ash", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer")
+{}
+
+export class CreateSpeechRequestResponseFormat extends S.Literal("mp3", "opus", "aac", "flac", "wav", "pcm") {}
+
 export class CreateSpeechRequest extends S.Class<CreateSpeechRequest>("CreateSpeechRequest")({
-  "model": S.Union(S.String, S.Literal("tts-1", "tts-1-hd")),
+  "model": S.Union(S.String, CreateSpeechRequestModel),
   "input": S.String.pipe(S.maxLength(4096)),
-  "voice": S.Literal("alloy", "echo", "fable", "onyx", "nova", "shimmer"),
-  "response_format": S.optionalWith(S.Literal("mp3", "opus", "aac", "flac", "wav", "pcm"), {
+  "voice": CreateSpeechRequestVoice,
+  "response_format": S.optionalWith(CreateSpeechRequestResponseFormat, {
     nullable: true,
     default: () => "mp3" as const
   }),
@@ -325,9 +356,22 @@ export class ListBatchesParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const })
 }) {}
 
+export class BatchObject extends S.Literal("batch") {}
+
+export class BatchStatus extends S.Literal(
+  "validating",
+  "failed",
+  "in_progress",
+  "finalizing",
+  "completed",
+  "expired",
+  "cancelling",
+  "cancelled"
+) {}
+
 export class Batch extends S.Struct({
   "id": S.String,
-  "object": S.Literal("batch"),
+  "object": BatchObject,
   "endpoint": S.String,
   "errors": S.optionalWith(
     S.Struct({
@@ -346,16 +390,7 @@ export class Batch extends S.Struct({
   ),
   "input_file_id": S.String,
   "completion_window": S.String,
-  "status": S.Literal(
-    "validating",
-    "failed",
-    "in_progress",
-    "finalizing",
-    "completed",
-    "expired",
-    "cancelling",
-    "cancelled"
-  ),
+  "status": BatchStatus,
   "output_file_id": S.optionalWith(S.String, { nullable: true }),
   "error_file_id": S.optionalWith(S.String, { nullable: true }),
   "created_at": S.Int,
@@ -378,47 +413,78 @@ export class Batch extends S.Struct({
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class ListBatchesResponseObject extends S.Literal("list") {}
+
 export class ListBatchesResponse extends S.Class<ListBatchesResponse>("ListBatchesResponse")({
   "data": S.Array(Batch),
   "first_id": S.optionalWith(S.String, { nullable: true }),
   "last_id": S.optionalWith(S.String, { nullable: true }),
   "has_more": S.Boolean,
-  "object": S.Literal("list")
+  "object": ListBatchesResponseObject
 }) {}
 
+export class CreateBatchRequestEndpoint
+  extends S.Literal("/v1/chat/completions", "/v1/embeddings", "/v1/completions")
+{}
+
+export class CreateBatchRequestCompletionWindow extends S.Literal("24h") {}
+
 export class CreateBatchRequest extends S.Class<CreateBatchRequest>("CreateBatchRequest")({
   "input_file_id": S.String,
-  "endpoint": S.Literal("/v1/chat/completions", "/v1/embeddings", "/v1/completions"),
-  "completion_window": S.Literal("24h"),
+  "endpoint": CreateBatchRequestEndpoint,
+  "completion_window": CreateBatchRequestCompletionWindow,
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class ChatCompletionRequestMessageContentPartTextType extends S.Literal("text") {}
+
 export class ChatCompletionRequestMessageContentPartText extends S.Struct({
-  "type": S.Literal("text"),
+  "type": ChatCompletionRequestMessageContentPartTextType,
   "text": S.String
 }) {}
 
+export class ChatCompletionRequestDeveloperMessageRole extends S.Literal("developer") {}
+
+export class ChatCompletionRequestDeveloperMessage extends S.Struct({
+  "content": S.Union(S.String, S.NonEmptyArray(ChatCompletionRequestMessageContentPartText)),
+  "role": ChatCompletionRequestDeveloperMessageRole,
+  "name": S.optionalWith(S.String, { nullable: true })
+}) {}
+
 export class ChatCompletionRequestSystemMessageContentPart extends ChatCompletionRequestMessageContentPartText {}
 
+export class ChatCompletionRequestSystemMessageRole extends S.Literal("system") {}
+
 export class ChatCompletionRequestSystemMessage extends S.Struct({
   "content": S.Union(S.String, S.NonEmptyArray(ChatCompletionRequestSystemMessageContentPart)),
-  "role": S.Literal("system"),
+  "role": ChatCompletionRequestSystemMessageRole,
   "name": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class ChatCompletionRequestMessageContentPartImageType extends S.Literal("image_url") {}
+
+export class ChatCompletionRequestMessageContentPartImageImageUrlDetail extends S.Literal("auto", "low", "high") {}
+
 export class ChatCompletionRequestMessageContentPartImage extends S.Struct({
-  "type": S.Literal("image_url"),
+  "type": ChatCompletionRequestMessageContentPartImageType,
   "image_url": S.Struct({
     "url": S.String,
-    "detail": S.optionalWith(S.Literal("auto", "low", "high"), { nullable: true, default: () => "auto" as const })
+    "detail": S.optionalWith(ChatCompletionRequestMessageContentPartImageImageUrlDetail, {
+      nullable: true,
+      default: () => "auto" as const
+    })
   })
 }) {}
 
+export class ChatCompletionRequestMessageContentPartAudioType extends S.Literal("input_audio") {}
+
+export class ChatCompletionRequestMessageContentPartAudioInputAudioFormat extends S.Literal("wav", "mp3") {}
+
 export class ChatCompletionRequestMessageContentPartAudio extends S.Struct({
-  "type": S.Literal("input_audio"),
+  "type": ChatCompletionRequestMessageContentPartAudioType,
   "input_audio": S.Struct({
     "data": S.String,
-    "format": S.Literal("wav", "mp3")
+    "format": ChatCompletionRequestMessageContentPartAudioInputAudioFormat
   })
 }) {}
 
@@ -428,14 +494,18 @@ export class ChatCompletionRequestUserMessageContentPart extends S.Union(
   ChatCompletionRequestMessageContentPartAudio
 ) {}
 
+export class ChatCompletionRequestUserMessageRole extends S.Literal("user") {}
+
 export class ChatCompletionRequestUserMessage extends S.Struct({
   "content": S.Union(S.String, S.NonEmptyArray(ChatCompletionRequestUserMessageContentPart)),
-  "role": S.Literal("user"),
+  "role": ChatCompletionRequestUserMessageRole,
   "name": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class ChatCompletionRequestMessageContentPartRefusalType extends S.Literal("refusal") {}
+
 export class ChatCompletionRequestMessageContentPartRefusal extends S.Struct({
-  "type": S.Literal("refusal"),
+  "type": ChatCompletionRequestMessageContentPartRefusalType,
   "refusal": S.String
 }) {}
 
@@ -443,9 +513,13 @@ export class ChatCompletionRequestAssistantMessageContentPart
   extends S.Union(ChatCompletionRequestMessageContentPartText, ChatCompletionRequestMessageContentPartRefusal)
 {}
 
+export class ChatCompletionRequestAssistantMessageRole extends S.Literal("assistant") {}
+
+export class ChatCompletionMessageToolCallType extends S.Literal("function") {}
+
 export class ChatCompletionMessageToolCall extends S.Struct({
   "id": S.String,
-  "type": S.Literal("function"),
+  "type": ChatCompletionMessageToolCallType,
   "function": S.Struct({
     "name": S.String,
     "arguments": S.String
@@ -459,7 +533,7 @@ export class ChatCompletionRequestAssistantMessage extends S.Struct({
     nullable: true
   }),
   "refusal": S.optionalWith(S.String, { nullable: true }),
-  "role": S.Literal("assistant"),
+  "role": ChatCompletionRequestAssistantMessageRole,
   "name": S.optionalWith(S.String, { nullable: true }),
   "audio": S.optionalWith(
     S.Struct({
@@ -477,21 +551,26 @@ export class ChatCompletionRequestAssistantMessage extends S.Struct({
   )
 }) {}
 
+export class ChatCompletionRequestToolMessageRole extends S.Literal("tool") {}
+
 export class ChatCompletionRequestToolMessageContentPart extends ChatCompletionRequestMessageContentPartText {}
 
 export class ChatCompletionRequestToolMessage extends S.Struct({
-  "role": S.Literal("tool"),
+  "role": ChatCompletionRequestToolMessageRole,
   "content": S.Union(S.String, S.NonEmptyArray(ChatCompletionRequestToolMessageContentPart)),
   "tool_call_id": S.String
 }) {}
 
+export class ChatCompletionRequestFunctionMessageRole extends S.Literal("function") {}
+
 export class ChatCompletionRequestFunctionMessage extends S.Struct({
-  "role": S.Literal("function"),
+  "role": ChatCompletionRequestFunctionMessageRole,
   "content": S.NullOr(S.String),
   "name": S.String
 }) {}
 
 export class ChatCompletionRequestMessage extends S.Union(
+  ChatCompletionRequestDeveloperMessage,
   ChatCompletionRequestSystemMessage,
   ChatCompletionRequestUserMessage,
   ChatCompletionRequestAssistantMessage,
@@ -499,19 +578,80 @@ export class ChatCompletionRequestMessage extends S.Union(
   ChatCompletionRequestFunctionMessage
 ) {}
 
+export class CreateChatCompletionRequestModel extends S.Literal(
+  "o1",
+  "o1-2024-12-17",
+  "o1-preview",
+  "o1-preview-2024-09-12",
+  "o1-mini",
+  "o1-mini-2024-09-12",
+  "gpt-4o",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-audio-preview",
+  "gpt-4o-audio-preview-2024-10-01",
+  "gpt-4o-audio-preview-2024-12-17",
+  "gpt-4o-mini-audio-preview",
+  "gpt-4o-mini-audio-preview-2024-12-17",
+  "chatgpt-4o-latest",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-0125-preview",
+  "gpt-4-turbo-preview",
+  "gpt-4-1106-preview",
+  "gpt-4-vision-preview",
+  "gpt-4",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-0301",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-1106",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo-16k-0613"
+) {}
+
+export class CreateChatCompletionRequestReasoningEffort extends S.Literal("low", "medium", "high") {}
+
 export class ChatCompletionModalities extends S.Array(S.Literal("text", "audio")) {}
 
+export class PredictionContentType extends S.Literal("content") {}
+
+export class PredictionContent extends S.Struct({
+  "type": PredictionContentType,
+  "content": S.Union(S.String, S.NonEmptyArray(ChatCompletionRequestMessageContentPartText))
+}) {}
+
+export class CreateChatCompletionRequestAudioVoice
+  extends S.Literal("alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse")
+{}
+
+export class CreateChatCompletionRequestAudioFormat extends S.Literal("wav", "mp3", "flac", "opus", "pcm16") {}
+
+export class CreateChatCompletionRequestServiceTier extends S.Literal("auto", "default") {}
+
 export class ChatCompletionStreamOptions extends S.Struct({
   "include_usage": S.optionalWith(S.Boolean, { nullable: true })
 }) {}
 
+export class ChatCompletionToolType extends S.Literal("function") {}
+
 export class ChatCompletionTool extends S.Struct({
-  "type": S.Literal("function"),
+  "type": ChatCompletionToolType,
   "function": FunctionObject
 }) {}
 
+export class ChatCompletionNamedToolChoiceType extends S.Literal("function") {}
+
 export class ChatCompletionNamedToolChoice extends S.Struct({
-  "type": S.Literal("function"),
+  "type": ChatCompletionNamedToolChoiceType,
   "function": S.Struct({
     "name": S.String
   })
@@ -523,6 +663,8 @@ export class ChatCompletionToolChoiceOption
 
 export class ParallelToolCalls extends S.Boolean {}
 
+export class CreateChatCompletionRequestFunctionCall extends S.Literal("none", "auto") {}
+
 export class ChatCompletionFunctionCallOption extends S.Struct({
   "name": S.String
 }) {}
@@ -535,46 +677,12 @@ export class ChatCompletionFunctions extends S.Struct({
 
 export class CreateChatCompletionRequest extends S.Class<CreateChatCompletionRequest>("CreateChatCompletionRequest")({
   "messages": S.NonEmptyArray(ChatCompletionRequestMessage),
-  "model": S.Union(
-    S.String,
-    S.Literal(
-      "o1-preview",
-      "o1-preview-2024-09-12",
-      "o1-mini",
-      "o1-mini-2024-09-12",
-      "gpt-4o",
-      "gpt-4o-2024-08-06",
-      "gpt-4o-2024-05-13",
-      "gpt-4o-2024-08-06",
-      "gpt-4o-realtime-preview",
-      "gpt-4o-realtime-preview-2024-10-01",
-      "gpt-4o-audio-preview",
-      "gpt-4o-audio-preview-2024-10-01",
-      "chatgpt-4o-latest",
-      "gpt-4o-mini",
-      "gpt-4o-mini-2024-07-18",
-      "gpt-4-turbo",
-      "gpt-4-turbo-2024-04-09",
-      "gpt-4-0125-preview",
-      "gpt-4-turbo-preview",
-      "gpt-4-1106-preview",
-      "gpt-4-vision-preview",
-      "gpt-4",
-      "gpt-4-0314",
-      "gpt-4-0613",
-      "gpt-4-32k",
-      "gpt-4-32k-0314",
-      "gpt-4-32k-0613",
-      "gpt-3.5-turbo",
-      "gpt-3.5-turbo-16k",
-      "gpt-3.5-turbo-0301",
-      "gpt-3.5-turbo-0613",
-      "gpt-3.5-turbo-1106",
-      "gpt-3.5-turbo-0125",
-      "gpt-3.5-turbo-16k-0613"
-    )
-  ),
+  "model": S.Union(S.String, CreateChatCompletionRequestModel),
   "store": S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+  "reasoning_effort": S.optionalWith(CreateChatCompletionRequestReasoningEffort, {
+    nullable: true,
+    default: () => "medium" as const
+  }),
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true }),
   "frequency_penalty": S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(-2), S.lessThanOrEqualTo(2)), {
     nullable: true,
@@ -590,10 +698,11 @@ export class CreateChatCompletionRequest extends S.Class<CreateChatCompletionReq
     default: () => 1 as const
   }),
   "modalities": S.optionalWith(ChatCompletionModalities, { nullable: true }),
+  "prediction": S.optionalWith(PredictionContent, { nullable: true }),
   "audio": S.optionalWith(
     S.Struct({
-      "voice": S.Literal("alloy", "echo", "fable", "onyx", "nova", "shimmer"),
-      "format": S.Literal("wav", "mp3", "flac", "opus", "pcm16")
+      "voice": CreateChatCompletionRequestAudioVoice,
+      "format": CreateChatCompletionRequestAudioFormat
     }),
     { nullable: true }
   ),
@@ -604,11 +713,11 @@ export class CreateChatCompletionRequest extends S.Class<CreateChatCompletionReq
   "response_format": S.optionalWith(S.Union(ResponseFormatText, ResponseFormatJsonObject, ResponseFormatJsonSchema), {
     nullable: true
   }),
-  "seed": S.optionalWith(
-    S.Int.pipe(S.greaterThanOrEqualTo(-9223372036854776000), S.lessThanOrEqualTo(9223372036854776000)),
-    { nullable: true }
-  ),
-  "service_tier": S.optionalWith(S.Literal("auto", "default"), { nullable: true, default: () => "auto" as const }),
+  "seed": S.optionalWith(S.Int, { nullable: true }),
+  "service_tier": S.optionalWith(CreateChatCompletionRequestServiceTier, {
+    nullable: true,
+    default: () => "auto" as const
+  }),
   "stop": S.optionalWith(S.Union(S.String, S.Array(S.String).pipe(S.minItems(1), S.maxItems(4))), { nullable: true }),
   "stream": S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
   "stream_options": S.optionalWith(ChatCompletionStreamOptions, { nullable: true }),
@@ -624,17 +733,23 @@ export class CreateChatCompletionRequest extends S.Class<CreateChatCompletionReq
   "tool_choice": S.optionalWith(ChatCompletionToolChoiceOption, { nullable: true }),
   "parallel_tool_calls": S.optionalWith(ParallelToolCalls, { nullable: true, default: () => true as const }),
   "user": S.optionalWith(S.String, { nullable: true }),
-  "function_call": S.optionalWith(S.Union(S.Literal("none", "auto"), ChatCompletionFunctionCallOption), {
+  "function_call": S.optionalWith(S.Union(CreateChatCompletionRequestFunctionCall, ChatCompletionFunctionCallOption), {
     nullable: true
   }),
   "functions": S.optionalWith(S.Array(ChatCompletionFunctions).pipe(S.minItems(1), S.maxItems(128)), { nullable: true })
 }) {}
 
+export class CreateChatCompletionResponseChoicesFinishReason
+  extends S.Literal("stop", "length", "tool_calls", "content_filter", "function_call")
+{}
+
+export class ChatCompletionResponseMessageRole extends S.Literal("assistant") {}
+
 export class ChatCompletionResponseMessage extends S.Struct({
   "content": S.NullOr(S.String),
   "refusal": S.NullOr(S.String),
   "tool_calls": S.optionalWith(ChatCompletionMessageToolCalls, { nullable: true }),
-  "role": S.Literal("assistant"),
+  "role": ChatCompletionResponseMessageRole,
   "function_call": S.optionalWith(
     S.Struct({
       "arguments": S.String,
@@ -664,14 +779,20 @@ export class ChatCompletionTokenLogprob extends S.Struct({
   }))
 }) {}
 
+export class CreateChatCompletionResponseServiceTier extends S.Literal("scale", "default") {}
+
+export class CreateChatCompletionResponseObject extends S.Literal("chat.completion") {}
+
 export class CompletionUsage extends S.Struct({
   "completion_tokens": S.Int,
   "prompt_tokens": S.Int,
   "total_tokens": S.Int,
   "completion_tokens_details": S.optionalWith(
     S.Struct({
+      "accepted_prediction_tokens": S.optionalWith(S.Int, { nullable: true }),
       "audio_tokens": S.optionalWith(S.Int, { nullable: true }),
-      "reasoning_tokens": S.optionalWith(S.Int, { nullable: true })
+      "reasoning_tokens": S.optionalWith(S.Int, { nullable: true }),
+      "rejected_prediction_tokens": S.optionalWith(S.Int, { nullable: true })
     }),
     { nullable: true }
   ),
@@ -688,7 +809,7 @@ export class CreateChatCompletionResponse
   extends S.Class<CreateChatCompletionResponse>("CreateChatCompletionResponse")({
     "id": S.String,
     "choices": S.Array(S.Struct({
-      "finish_reason": S.Literal("stop", "length", "tool_calls", "content_filter", "function_call"),
+      "finish_reason": CreateChatCompletionResponseChoicesFinishReason,
       "index": S.Int,
       "message": ChatCompletionResponseMessage,
       "logprobs": S.NullOr(S.Struct({
@@ -698,15 +819,17 @@ export class CreateChatCompletionResponse
     })),
     "created": S.Int,
     "model": S.String,
-    "service_tier": S.optionalWith(S.Literal("scale", "default"), { nullable: true }),
+    "service_tier": S.optionalWith(CreateChatCompletionResponseServiceTier, { nullable: true }),
     "system_fingerprint": S.optionalWith(S.String, { nullable: true }),
-    "object": S.Literal("chat.completion"),
+    "object": CreateChatCompletionResponseObject,
     "usage": S.optionalWith(CompletionUsage, { nullable: true })
   })
 {}
 
+export class CreateCompletionRequestModel extends S.Literal("gpt-3.5-turbo-instruct", "davinci-002", "babbage-002") {}
+
 export class CreateCompletionRequest extends S.Class<CreateCompletionRequest>("CreateCompletionRequest")({
-  "model": S.Union(S.String, S.Literal("gpt-3.5-turbo-instruct", "davinci-002", "babbage-002")),
+  "model": S.Union(S.String, CreateCompletionRequestModel),
   "prompt": S.NullOr(
     S.Union(S.String, S.Array(S.String), S.NonEmptyArray(S.Int), S.NonEmptyArray(S.NonEmptyArray(S.Int)))
   ).pipe(S.propertySignature, S.withConstructorDefault(() => "<|endoftext|>" as const)),
@@ -730,10 +853,7 @@ export class CreateCompletionRequest extends S.Class<CreateCompletionRequest>("C
     nullable: true,
     default: () => 0 as const
   }),
-  "seed": S.optionalWith(
-    S.Int.pipe(S.greaterThanOrEqualTo(-9223372036854776000), S.lessThanOrEqualTo(9223372036854776000)),
-    { nullable: true }
-  ),
+  "seed": S.optionalWith(S.Int, { nullable: true }),
   "stop": S.optionalWith(S.Union(S.String, S.Array(S.String).pipe(S.minItems(1), S.maxItems(4))), { nullable: true }),
   "stream": S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
   "stream_options": S.optionalWith(ChatCompletionStreamOptions, { nullable: true }),
@@ -749,10 +869,14 @@ export class CreateCompletionRequest extends S.Class<CreateCompletionRequest>("C
   "user": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class CreateCompletionResponseChoicesFinishReason extends S.Literal("stop", "length", "content_filter") {}
+
+export class CreateCompletionResponseObject extends S.Literal("text_completion") {}
+
 export class CreateCompletionResponse extends S.Class<CreateCompletionResponse>("CreateCompletionResponse")({
   "id": S.String,
   "choices": S.Array(S.Struct({
-    "finish_reason": S.Literal("stop", "length", "content_filter"),
+    "finish_reason": CreateCompletionResponseChoicesFinishReason,
     "index": S.Int,
     "logprobs": S.NullOr(S.Struct({
       "text_offset": S.optionalWith(S.Array(S.Int), { nullable: true }),
@@ -765,10 +889,16 @@ export class CreateCompletionResponse extends S.Class<CreateCompletionResponse>(
   "created": S.Int,
   "model": S.String,
   "system_fingerprint": S.optionalWith(S.String, { nullable: true }),
-  "object": S.Literal("text_completion"),
+  "object": CreateCompletionResponseObject,
   "usage": S.optionalWith(CompletionUsage, { nullable: true })
 }) {}
 
+export class CreateEmbeddingRequestModel
+  extends S.Literal("text-embedding-ada-002", "text-embedding-3-small", "text-embedding-3-large")
+{}
+
+export class CreateEmbeddingRequestEncodingFormat extends S.Literal("float", "base64") {}
+
 export class CreateEmbeddingRequest extends S.Class<CreateEmbeddingRequest>("CreateEmbeddingRequest")({
   "input": S.Union(
     S.String,
@@ -776,59 +906,82 @@ export class CreateEmbeddingRequest extends S.Class<CreateEmbeddingRequest>("Cre
     S.Array(S.Int).pipe(S.minItems(1), S.maxItems(2048)),
     S.Array(S.NonEmptyArray(S.Int)).pipe(S.minItems(1), S.maxItems(2048))
   ),
-  "model": S.Union(S.String, S.Literal("text-embedding-ada-002", "text-embedding-3-small", "text-embedding-3-large")),
-  "encoding_format": S.optionalWith(S.Literal("float", "base64"), { nullable: true, default: () => "float" as const }),
+  "model": S.Union(S.String, CreateEmbeddingRequestModel),
+  "encoding_format": S.optionalWith(CreateEmbeddingRequestEncodingFormat, {
+    nullable: true,
+    default: () => "float" as const
+  }),
   "dimensions": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
   "user": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class EmbeddingObject extends S.Literal("embedding") {}
+
 export class Embedding extends S.Struct({
   "index": S.Int,
   "embedding": S.Array(S.Number),
-  "object": S.Literal("embedding")
+  "object": EmbeddingObject
 }) {}
 
+export class CreateEmbeddingResponseObject extends S.Literal("list") {}
+
 export class CreateEmbeddingResponse extends S.Class<CreateEmbeddingResponse>("CreateEmbeddingResponse")({
   "data": S.Array(Embedding),
   "model": S.String,
-  "object": S.Literal("list"),
+  "object": CreateEmbeddingResponseObject,
   "usage": S.Struct({
     "prompt_tokens": S.Int,
     "total_tokens": S.Int
   })
 }) {}
 
+export class ListFilesParamsOrder extends S.Literal("asc", "desc") {}
+
 export class ListFilesParams extends S.Struct({
-  "purpose": S.optionalWith(S.String, { nullable: true })
+  "purpose": S.optionalWith(S.String, { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true, default: () => 10000 as const }),
+  "order": S.optionalWith(ListFilesParamsOrder, { nullable: true, default: () => "desc" as const }),
+  "after": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class OpenAIFileObject extends S.Literal("file") {}
+
+export class OpenAIFilePurpose extends S.Literal(
+  "assistants",
+  "assistants_output",
+  "batch",
+  "batch_output",
+  "fine-tune",
+  "fine-tune-results",
+  "vision"
+) {}
+
+export class OpenAIFileStatus extends S.Literal("uploaded", "processed", "error") {}
+
 export class OpenAIFile extends S.Struct({
   "id": S.String,
   "bytes": S.Int,
   "created_at": S.Int,
   "filename": S.String,
-  "object": S.Literal("file"),
-  "purpose": S.Literal(
-    "assistants",
-    "assistants_output",
-    "batch",
-    "batch_output",
-    "fine-tune",
-    "fine-tune-results",
-    "vision"
-  ),
-  "status": S.Literal("uploaded", "processed", "error"),
+  "object": OpenAIFileObject,
+  "purpose": OpenAIFilePurpose,
+  "status": OpenAIFileStatus,
   "status_details": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class ListFilesResponse extends S.Class<ListFilesResponse>("ListFilesResponse")({
+  "object": S.String,
   "data": S.Array(OpenAIFile),
-  "object": S.Literal("list")
+  "first_id": S.String,
+  "last_id": S.String,
+  "has_more": S.Boolean
 }) {}
 
+export class DeleteFileResponseObject extends S.Literal("file") {}
+
 export class DeleteFileResponse extends S.Class<DeleteFileResponse>("DeleteFileResponse")({
   "id": S.String,
-  "object": S.Literal("file"),
+  "object": DeleteFileResponseObject,
   "deleted": S.Boolean
 }) {}
 
@@ -839,8 +992,22 @@ export class ListPaginatedFineTuningJobsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const })
 }) {}
 
+export class FineTuningJobHyperparametersBatchSize extends S.Literal("auto") {}
+
+export class FineTuningJobHyperparametersLearningRateMultiplier extends S.Literal("auto") {}
+
+export class FineTuningJobHyperparametersNEpochs extends S.Literal("auto") {}
+
+export class FineTuningJobObject extends S.Literal("fine_tuning.job") {}
+
+export class FineTuningJobStatus
+  extends S.Literal("validating_files", "queued", "running", "succeeded", "failed", "cancelled")
+{}
+
+export class FineTuningIntegrationType extends S.Literal("wandb") {}
+
 export class FineTuningIntegration extends S.Struct({
-  "type": S.Literal("wandb"),
+  "type": FineTuningIntegrationType,
   "wandb": S.Struct({
     "project": S.String,
     "name": S.optionalWith(S.String, { nullable: true }),
@@ -849,6 +1016,93 @@ export class FineTuningIntegration extends S.Struct({
   })
 }) {}
 
+export class FineTuneMethodType extends S.Literal("supervised", "dpo") {}
+
+export class FineTuneSupervisedMethodHyperparametersBatchSize extends S.Literal("auto") {}
+
+export class FineTuneSupervisedMethodHyperparametersLearningRateMultiplier extends S.Literal("auto") {}
+
+export class FineTuneSupervisedMethodHyperparametersNEpochs extends S.Literal("auto") {}
+
+export class FineTuneSupervisedMethod extends S.Struct({
+  "hyperparameters": S.optionalWith(
+    S.Struct({
+      "batch_size": S.optionalWith(
+        S.Union(
+          FineTuneSupervisedMethodHyperparametersBatchSize,
+          S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(256))
+        ),
+        { nullable: true, default: () => "auto" as const }
+      ),
+      "learning_rate_multiplier": S.optionalWith(
+        S.Union(FineTuneSupervisedMethodHyperparametersLearningRateMultiplier, S.Number.pipe(S.greaterThan(0))),
+        {
+          nullable: true,
+          default: () => "auto" as const
+        }
+      ),
+      "n_epochs": S.optionalWith(
+        S.Union(
+          FineTuneSupervisedMethodHyperparametersNEpochs,
+          S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50))
+        ),
+        { nullable: true, default: () => "auto" as const }
+      )
+    }),
+    { nullable: true }
+  )
+}) {}
+
+export class FineTuneDPOMethodHyperparametersBeta extends S.Literal("auto") {}
+
+export class FineTuneDPOMethodHyperparametersBatchSize extends S.Literal("auto") {}
+
+export class FineTuneDPOMethodHyperparametersLearningRateMultiplier extends S.Literal("auto") {}
+
+export class FineTuneDPOMethodHyperparametersNEpochs extends S.Literal("auto") {}
+
+export class FineTuneDPOMethod extends S.Struct({
+  "hyperparameters": S.optionalWith(
+    S.Struct({
+      "beta": S.optionalWith(
+        S.Union(FineTuneDPOMethodHyperparametersBeta, S.Number.pipe(S.greaterThan(0), S.lessThanOrEqualTo(2))),
+        {
+          nullable: true,
+          default: () => "auto" as const
+        }
+      ),
+      "batch_size": S.optionalWith(
+        S.Union(
+          FineTuneDPOMethodHyperparametersBatchSize,
+          S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(256))
+        ),
+        { nullable: true, default: () => "auto" as const }
+      ),
+      "learning_rate_multiplier": S.optionalWith(
+        S.Union(FineTuneDPOMethodHyperparametersLearningRateMultiplier, S.Number.pipe(S.greaterThan(0))),
+        {
+          nullable: true,
+          default: () => "auto" as const
+        }
+      ),
+      "n_epochs": S.optionalWith(
+        S.Union(
+          FineTuneDPOMethodHyperparametersNEpochs,
+          S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50))
+        ),
+        { nullable: true, default: () => "auto" as const }
+      )
+    }),
+    { nullable: true }
+  )
+}) {}
+
+export class FineTuneMethod extends S.Struct({
+  "type": S.optionalWith(FineTuneMethodType, { nullable: true }),
+  "supervised": S.optionalWith(FineTuneSupervisedMethod, { nullable: true }),
+  "dpo": S.optionalWith(FineTuneDPOMethod, { nullable: true })
+}) {}
+
 export class FineTuningJob extends S.Struct({
   "id": S.String,
   "created_at": S.Int,
@@ -860,54 +1114,89 @@ export class FineTuningJob extends S.Struct({
   "fine_tuned_model": S.NullOr(S.String),
   "finished_at": S.NullOr(S.Int),
   "hyperparameters": S.Struct({
-    "n_epochs": S.Union(S.Literal("auto"), S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50))).pipe(
-      S.propertySignature,
-      S.withConstructorDefault(() => "auto" as const)
+    "batch_size": S.optionalWith(
+      S.Union(FineTuningJobHyperparametersBatchSize, S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(256))),
+      {
+        nullable: true,
+        default: () => "auto" as const
+      }
+    ),
+    "learning_rate_multiplier": S.optionalWith(
+      S.Union(FineTuningJobHyperparametersLearningRateMultiplier, S.Number.pipe(S.greaterThan(0))),
+      {
+        nullable: true,
+        default: () => "auto" as const
+      }
+    ),
+    "n_epochs": S.optionalWith(
+      S.Union(FineTuningJobHyperparametersNEpochs, S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50))),
+      {
+        nullable: true,
+        default: () => "auto" as const
+      }
     )
   }),
   "model": S.String,
-  "object": S.Literal("fine_tuning.job"),
+  "object": FineTuningJobObject,
   "organization_id": S.String,
   "result_files": S.Array(S.String),
-  "status": S.Literal("validating_files", "queued", "running", "succeeded", "failed", "cancelled"),
+  "status": FineTuningJobStatus,
   "trained_tokens": S.NullOr(S.Int),
   "training_file": S.String,
   "validation_file": S.NullOr(S.String),
   "integrations": S.optionalWith(S.Array(FineTuningIntegration).pipe(S.maxItems(5)), { nullable: true }),
   "seed": S.Int,
-  "estimated_finish": S.optionalWith(S.Int, { nullable: true })
+  "estimated_finish": S.optionalWith(S.Int, { nullable: true }),
+  "method": S.optionalWith(FineTuneMethod, { nullable: true })
 }) {}
 
+export class ListPaginatedFineTuningJobsResponseObject extends S.Literal("list") {}
+
 export class ListPaginatedFineTuningJobsResponse
   extends S.Class<ListPaginatedFineTuningJobsResponse>("ListPaginatedFineTuningJobsResponse")({
     "data": S.Array(FineTuningJob),
     "has_more": S.Boolean,
-    "object": S.Literal("list")
+    "object": ListPaginatedFineTuningJobsResponseObject
   })
 {}
 
+export class CreateFineTuningJobRequestModel
+  extends S.Literal("babbage-002", "davinci-002", "gpt-3.5-turbo", "gpt-4o-mini")
+{}
+
+export class CreateFineTuningJobRequestHyperparametersBatchSize extends S.Literal("auto") {}
+
+export class CreateFineTuningJobRequestHyperparametersLearningRateMultiplier extends S.Literal("auto") {}
+
+export class CreateFineTuningJobRequestHyperparametersNEpochs extends S.Literal("auto") {}
+
+export class CreateFineTuningJobRequestIntegrationsType extends S.Literal("wandb") {}
+
 export class CreateFineTuningJobRequest extends S.Class<CreateFineTuningJobRequest>("CreateFineTuningJobRequest")({
-  "model": S.Union(S.String, S.Literal("babbage-002", "davinci-002", "gpt-3.5-turbo", "gpt-4o-mini")),
+  "model": S.Union(S.String, CreateFineTuningJobRequestModel),
   "training_file": S.String,
   "hyperparameters": S.optionalWith(
     S.Struct({
       "batch_size": S.optionalWith(
-        S.Union(S.Literal("auto"), S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(256))),
+        S.Union(
+          CreateFineTuningJobRequestHyperparametersBatchSize,
+          S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(256))
+        ),
+        { nullable: true, default: () => "auto" as const }
+      ),
+      "learning_rate_multiplier": S.optionalWith(
+        S.Union(CreateFineTuningJobRequestHyperparametersLearningRateMultiplier, S.Number.pipe(S.greaterThan(0))),
         {
           nullable: true,
           default: () => "auto" as const
         }
       ),
-      "learning_rate_multiplier": S.optionalWith(S.Union(S.Literal("auto"), S.Number.pipe(S.greaterThan(0))), {
-        nullable: true,
-        default: () => "auto" as const
-      }),
       "n_epochs": S.optionalWith(
-        S.Union(S.Literal("auto"), S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50))),
-        {
-          nullable: true,
-          default: () => "auto" as const
-        }
+        S.Union(
+          CreateFineTuningJobRequestHyperparametersNEpochs,
+          S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50))
+        ),
+        { nullable: true, default: () => "auto" as const }
       )
     }),
     { nullable: true }
@@ -916,7 +1205,7 @@ export class CreateFineTuningJobRequest extends S.Class<CreateFineTuningJobReque
   "validation_file": S.optionalWith(S.String, { nullable: true }),
   "integrations": S.optionalWith(
     S.Array(S.Struct({
-      "type": S.Literal("wandb"),
+      "type": CreateFineTuningJobRequestIntegrationsType,
       "wandb": S.Struct({
         "project": S.String,
         "name": S.optionalWith(S.String, { nullable: true }),
@@ -926,7 +1215,8 @@ export class CreateFineTuningJobRequest extends S.Class<CreateFineTuningJobReque
     })),
     { nullable: true }
   ),
-  "seed": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(2147483647)), { nullable: true })
+  "seed": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(2147483647)), { nullable: true }),
+  "method": S.optionalWith(FineTuneMethod, { nullable: true })
 }) {}
 
 export class ListFineTuningJobCheckpointsParams extends S.Struct({
@@ -934,6 +1224,8 @@ export class ListFineTuningJobCheckpointsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 10 as const })
 }) {}
 
+export class FineTuningJobCheckpointObject extends S.Literal("fine_tuning.job.checkpoint") {}
+
 export class FineTuningJobCheckpoint extends S.Struct({
   "id": S.String,
   "created_at": S.Int,
@@ -949,13 +1241,15 @@ export class FineTuningJobCheckpoint extends S.Struct({
     "full_valid_mean_token_accuracy": S.optionalWith(S.Number, { nullable: true })
   }),
   "fine_tuning_job_id": S.String,
-  "object": S.Literal("fine_tuning.job.checkpoint")
+  "object": FineTuningJobCheckpointObject
 }) {}
 
+export class ListFineTuningJobCheckpointsResponseObject extends S.Literal("list") {}
+
 export class ListFineTuningJobCheckpointsResponse
   extends S.Class<ListFineTuningJobCheckpointsResponse>("ListFineTuningJobCheckpointsResponse")({
     "data": S.Array(FineTuningJobCheckpoint),
-    "object": S.Literal("list"),
+    "object": ListFineTuningJobCheckpointsResponseObject,
     "first_id": S.optionalWith(S.String, { nullable: true }),
     "last_id": S.optionalWith(S.String, { nullable: true }),
     "has_more": S.Boolean
@@ -967,18 +1261,28 @@ export class ListFineTuningEventsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const })
 }) {}
 
+export class FineTuningJobEventObject extends S.Literal("fine_tuning.job.event") {}
+
+export class FineTuningJobEventLevel extends S.Literal("info", "warn", "error") {}
+
+export class FineTuningJobEventType extends S.Literal("message", "metrics") {}
+
 export class FineTuningJobEvent extends S.Struct({
+  "object": FineTuningJobEventObject,
   "id": S.String,
   "created_at": S.Int,
-  "level": S.Literal("info", "warn", "error"),
+  "level": FineTuningJobEventLevel,
   "message": S.String,
-  "object": S.Literal("fine_tuning.job.event")
+  "type": S.optionalWith(FineTuningJobEventType, { nullable: true }),
+  "data": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class ListFineTuningJobEventsResponseObject extends S.Literal("list") {}
+
 export class ListFineTuningJobEventsResponse
   extends S.Class<ListFineTuningJobEventsResponse>("ListFineTuningJobEventsResponse")({
     "data": S.Array(FineTuningJobEvent),
-    "object": S.Literal("list")
+    "object": ListFineTuningJobEventsResponseObject
   })
 {}
 
@@ -993,9 +1297,19 @@ export class ImagesResponse extends S.Class<ImagesResponse>("ImagesResponse")({
   "data": S.Array(Image)
 }) {}
 
+export class CreateImageRequestModel extends S.Literal("dall-e-2", "dall-e-3") {}
+
+export class CreateImageRequestQuality extends S.Literal("standard", "hd") {}
+
+export class CreateImageRequestResponseFormat extends S.Literal("url", "b64_json") {}
+
+export class CreateImageRequestSize extends S.Literal("256x256", "512x512", "1024x1024", "1792x1024", "1024x1792") {}
+
+export class CreateImageRequestStyle extends S.Literal("vivid", "natural") {}
+
 export class CreateImageRequest extends S.Class<CreateImageRequest>("CreateImageRequest")({
   "prompt": S.String,
-  "model": S.optionalWith(S.Union(S.String, S.Literal("dall-e-2", "dall-e-3")), {
+  "model": S.optionalWith(S.Union(S.String, CreateImageRequestModel), {
     nullable: true,
     default: () => "dall-e-2" as const
   }),
@@ -1003,25 +1317,29 @@ export class CreateImageRequest extends S.Class<CreateImageRequest>("CreateImage
     nullable: true,
     default: () => 1 as const
   }),
-  "quality": S.optionalWith(S.Literal("standard", "hd"), { nullable: true, default: () => "standard" as const }),
-  "response_format": S.optionalWith(S.Literal("url", "b64_json"), { nullable: true, default: () => "url" as const }),
-  "size": S.optionalWith(S.Literal("256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"), {
+  "quality": S.optionalWith(CreateImageRequestQuality, { nullable: true, default: () => "standard" as const }),
+  "response_format": S.optionalWith(CreateImageRequestResponseFormat, {
     nullable: true,
-    default: () => "1024x1024" as const
+    default: () => "url" as const
   }),
-  "style": S.optionalWith(S.Literal("vivid", "natural"), { nullable: true, default: () => "vivid" as const }),
+  "size": S.optionalWith(CreateImageRequestSize, { nullable: true, default: () => "1024x1024" as const }),
+  "style": S.optionalWith(CreateImageRequestStyle, { nullable: true, default: () => "vivid" as const }),
   "user": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class ListModelsResponseObject extends S.Literal("list") {}
+
+export class ModelObject extends S.Literal("model") {}
+
 export class Model extends S.Struct({
   "id": S.String,
   "created": S.Int,
-  "object": S.Literal("model"),
+  "object": ModelObject,
   "owned_by": S.String
 }) {}
 
 export class ListModelsResponse extends S.Class<ListModelsResponse>("ListModelsResponse")({
-  "object": S.Literal("list"),
+  "object": ListModelsResponseObject,
   "data": S.Array(Model)
 }) {}
 
@@ -1031,37 +1349,70 @@ export class DeleteModelResponse extends S.Class<DeleteModelResponse>("DeleteMod
   "object": S.String
 }) {}
 
+export class CreateModerationRequestInputType extends S.Literal("text") {}
+
+export class CreateModerationRequestModel extends S.Literal(
+  "omni-moderation-latest",
+  "omni-moderation-2024-09-26",
+  "text-moderation-latest",
+  "text-moderation-stable"
+) {}
+
 export class CreateModerationRequest extends S.Class<CreateModerationRequest>("CreateModerationRequest")({
   "input": S.Union(
     S.String,
     S.Array(S.String),
     S.Array(S.Union(
       S.Struct({
-        "type": S.Literal("image_url"),
+        "type": CreateModerationRequestInputType,
         "image_url": S.Struct({
           "url": S.String
         })
       }),
       S.Struct({
-        "type": S.Literal("text"),
+        "type": CreateModerationRequestInputType,
         "text": S.String
       })
     ))
   ),
-  "model": S.optionalWith(
-    S.Union(
-      S.String,
-      S.Literal(
-        "omni-moderation-latest",
-        "omni-moderation-2024-09-26",
-        "text-moderation-latest",
-        "text-moderation-stable"
-      )
-    ),
-    { nullable: true, default: () => "omni-moderation-latest" as const }
-  )
+  "model": S.optionalWith(S.Union(S.String, CreateModerationRequestModel), {
+    nullable: true,
+    default: () => "omni-moderation-latest" as const
+  })
 }) {}
 
+export class CreateModerationResponseResultsCategoryAppliedInputTypesHate extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesHateThreatening extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesHarassment extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesHarassmentThreatening extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesIllicit extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesIllicitViolent extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesSelfHarm extends S.Literal("text", "image") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesSelfHarmIntent
+  extends S.Literal("text", "image")
+{}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesSelfHarmInstructions
+  extends S.Literal("text", "image")
+{}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesSexual extends S.Literal("text", "image") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesSexualMinors extends S.Literal("text") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesViolence extends S.Literal("text", "image") {}
+
+export class CreateModerationResponseResultsCategoryAppliedInputTypesViolenceGraphic
+  extends S.Literal("text", "image")
+{}
+
 export class CreateModerationResponse extends S.Class<CreateModerationResponse>("CreateModerationResponse")({
   "id": S.String,
   "model": S.String,
@@ -1098,23 +1449,68 @@ export class CreateModerationResponse extends S.Class<CreateModerationResponse>(
       "violence/graphic": S.Number
     }),
     "category_applied_input_types": S.Struct({
-      "hate": S.Array(S.Literal("text")),
-      "hate/threatening": S.Array(S.Literal("text")),
-      "harassment": S.Array(S.Literal("text")),
-      "harassment/threatening": S.Array(S.Literal("text")),
-      "illicit": S.Array(S.Literal("text")),
-      "illicit/violent": S.Array(S.Literal("text")),
-      "self-harm": S.Array(S.Literal("text", "image")),
-      "self-harm/intent": S.Array(S.Literal("text", "image")),
-      "self-harm/instructions": S.Array(S.Literal("text", "image")),
-      "sexual": S.Array(S.Literal("text", "image")),
-      "sexual/minors": S.Array(S.Literal("text")),
-      "violence": S.Array(S.Literal("text", "image")),
-      "violence/graphic": S.Array(S.Literal("text", "image"))
+      "hate": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesHate),
+      "hate/threatening": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesHateThreatening),
+      "harassment": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesHarassment),
+      "harassment/threatening": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesHarassmentThreatening),
+      "illicit": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesIllicit),
+      "illicit/violent": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesIllicitViolent),
+      "self-harm": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesSelfHarm),
+      "self-harm/intent": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesSelfHarmIntent),
+      "self-harm/instructions": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesSelfHarmInstructions),
+      "sexual": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesSexual),
+      "sexual/minors": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesSexualMinors),
+      "violence": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesViolence),
+      "violence/graphic": S.Array(CreateModerationResponseResultsCategoryAppliedInputTypesViolenceGraphic)
     })
   }))
 }) {}
 
+export class AdminApiKeysListParamsOrder extends S.Literal("asc", "desc") {}
+
+export class AdminApiKeysListParams extends S.Struct({
+  "after": S.optionalWith(S.String, { nullable: true }),
+  "order": S.optionalWith(AdminApiKeysListParamsOrder, { nullable: true, default: () => "asc" as const }),
+  "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const })
+}) {}
+
+export class AdminApiKey extends S.Struct({
+  "object": S.optionalWith(S.String, { nullable: true }),
+  "id": S.optionalWith(S.String, { nullable: true }),
+  "name": S.optionalWith(S.String, { nullable: true }),
+  "redacted_value": S.optionalWith(S.String, { nullable: true }),
+  "value": S.optionalWith(S.String, { nullable: true }),
+  "created_at": S.optionalWith(S.Int, { nullable: true }),
+  "owner": S.optionalWith(
+    S.Struct({
+      "type": S.optionalWith(S.String, { nullable: true }),
+      "id": S.optionalWith(S.String, { nullable: true }),
+      "name": S.optionalWith(S.String, { nullable: true }),
+      "created_at": S.optionalWith(S.Int, { nullable: true }),
+      "role": S.optionalWith(S.String, { nullable: true })
+    }),
+    { nullable: true }
+  )
+}) {}
+
+export class ApiKeyList extends S.Class<ApiKeyList>("ApiKeyList")({
+  "object": S.optionalWith(S.String, { nullable: true }),
+  "data": S.optionalWith(S.Array(AdminApiKey), { nullable: true }),
+  "has_more": S.optionalWith(S.Boolean, { nullable: true }),
+  "first_id": S.optionalWith(S.String, { nullable: true }),
+  "last_id": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class AdminApiKeysCreateRequest extends S.Class<AdminApiKeysCreateRequest>("AdminApiKeysCreateRequest")({
+  "name": S.String
+}) {}
+
+export class AdminApiKeysDelete200 extends S.Struct({
+  "id": S.optionalWith(S.String, { nullable: true }),
+  "object": S.optionalWith(S.String, { nullable: true }),
+  "deleted": S.optionalWith(S.Boolean, { nullable: true })
+}) {}
+
 export class AuditLogEventType extends S.Literal(
   "api_key.created",
   "api_key.updated",
@@ -1133,6 +1529,8 @@ export class AuditLogEventType extends S.Literal(
   "service_account.created",
   "service_account.updated",
   "service_account.deleted",
+  "rate_limit.updated",
+  "rate_limit.deleted",
   "user.added",
   "user.updated",
   "user.deleted"
@@ -1153,6 +1551,10 @@ export class ListAuditLogsParams extends S.Struct({
   "before": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class ListAuditLogsResponseObject extends S.Literal("list") {}
+
+export class AuditLogActorType extends S.Literal("session", "api_key") {}
+
 export class AuditLogActorUser extends S.Struct({
   "id": S.optionalWith(S.String, { nullable: true }),
   "email": S.optionalWith(S.String, { nullable: true })
@@ -1163,21 +1565,23 @@ export class AuditLogActorSession extends S.Struct({
   "ip_address": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class AuditLogActorApiKeyType extends S.Literal("user", "service_account") {}
+
 export class AuditLogActorServiceAccount extends S.Struct({
   "id": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class AuditLogActorApiKey extends S.Struct({
   "id": S.optionalWith(S.String, { nullable: true }),
-  "type": S.optionalWith(S.Literal("user", "service_account"), { nullable: true }),
+  "type": S.optionalWith(AuditLogActorApiKeyType, { nullable: true }),
   "user": S.optionalWith(AuditLogActorUser, { nullable: true }),
   "service_account": S.optionalWith(AuditLogActorServiceAccount, { nullable: true })
 }) {}
 
 export class AuditLogActor extends S.Struct({
-  "type": S.optionalWith(S.Literal("session", "api_key"), { nullable: true }),
-  "session": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true }),
-  "api_key": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
+  "type": S.optionalWith(AuditLogActorType, { nullable: true }),
+  "session": S.optionalWith(AuditLogActorSession, { nullable: true }),
+  "api_key": S.optionalWith(AuditLogActorApiKey, { nullable: true })
 }) {}
 
 export class AuditLog extends S.Struct({
@@ -1313,19 +1717,42 @@ export class AuditLog extends S.Struct({
     }),
     { nullable: true }
   ),
-  "service_account.created": S.optionalWith(
+  "rate_limit.updated": S.optionalWith(
     S.Struct({
       "id": S.optionalWith(S.String, { nullable: true }),
-      "data": S.optionalWith(
+      "changes_requested": S.optionalWith(
         S.Struct({
-          "role": S.optionalWith(S.String, { nullable: true })
+          "max_requests_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+          "max_tokens_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+          "max_images_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+          "max_audio_megabytes_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+          "max_requests_per_1_day": S.optionalWith(S.Int, { nullable: true }),
+          "batch_1_day_max_input_tokens": S.optionalWith(S.Int, { nullable: true })
         }),
         { nullable: true }
       )
     }),
     { nullable: true }
   ),
-  "service_account.updated": S.optionalWith(
+  "rate_limit.deleted": S.optionalWith(
+    S.Struct({
+      "id": S.optionalWith(S.String, { nullable: true })
+    }),
+    { nullable: true }
+  ),
+  "service_account.created": S.optionalWith(
+    S.Struct({
+      "id": S.optionalWith(S.String, { nullable: true }),
+      "data": S.optionalWith(
+        S.Struct({
+          "role": S.optionalWith(S.String, { nullable: true })
+        }),
+        { nullable: true }
+      )
+    }),
+    { nullable: true }
+  ),
+  "service_account.updated": S.optionalWith(
     S.Struct({
       "id": S.optionalWith(S.String, { nullable: true }),
       "changes_requested": S.optionalWith(
@@ -1376,44 +1803,230 @@ export class AuditLog extends S.Struct({
 }) {}
 
 export class ListAuditLogsResponse extends S.Class<ListAuditLogsResponse>("ListAuditLogsResponse")({
-  "object": S.Literal("list"),
+  "object": ListAuditLogsResponseObject,
   "data": S.Array(AuditLog),
   "first_id": S.String,
   "last_id": S.String,
   "has_more": S.Boolean
 }) {}
 
+export class UsageCostsParamsBucketWidth extends S.Literal("1d") {}
+
+export class UsageCostsParamsGroupBy extends S.Literal("project_id", "line_item") {}
+
+export class UsageCostsParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageCostsParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageCostsParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true, default: () => 7 as const }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageResponseObject extends S.Literal("page") {}
+
+export class UsageTimeBucketObject extends S.Literal("bucket") {}
+
+export class UsageCompletionsResultObject extends S.Literal("organization.usage.completions.result") {}
+
+export class UsageCompletionsResult extends S.Struct({
+  "object": UsageCompletionsResultObject,
+  "input_tokens": S.Int,
+  "input_cached_tokens": S.optionalWith(S.Int, { nullable: true }),
+  "output_tokens": S.Int,
+  "input_audio_tokens": S.optionalWith(S.Int, { nullable: true }),
+  "output_audio_tokens": S.optionalWith(S.Int, { nullable: true }),
+  "num_model_requests": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true }),
+  "user_id": S.optionalWith(S.String, { nullable: true }),
+  "api_key_id": S.optionalWith(S.String, { nullable: true }),
+  "model": S.optionalWith(S.String, { nullable: true }),
+  "batch": S.optionalWith(S.Boolean, { nullable: true })
+}) {}
+
+export class UsageEmbeddingsResultObject extends S.Literal("organization.usage.embeddings.result") {}
+
+export class UsageEmbeddingsResult extends S.Struct({
+  "object": UsageEmbeddingsResultObject,
+  "input_tokens": S.Int,
+  "num_model_requests": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true }),
+  "user_id": S.optionalWith(S.String, { nullable: true }),
+  "api_key_id": S.optionalWith(S.String, { nullable: true }),
+  "model": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageModerationsResultObject extends S.Literal("organization.usage.moderations.result") {}
+
+export class UsageModerationsResult extends S.Struct({
+  "object": UsageModerationsResultObject,
+  "input_tokens": S.Int,
+  "num_model_requests": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true }),
+  "user_id": S.optionalWith(S.String, { nullable: true }),
+  "api_key_id": S.optionalWith(S.String, { nullable: true }),
+  "model": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageImagesResultObject extends S.Literal("organization.usage.images.result") {}
+
+export class UsageImagesResult extends S.Struct({
+  "object": UsageImagesResultObject,
+  "images": S.Int,
+  "num_model_requests": S.Int,
+  "source": S.optionalWith(S.String, { nullable: true }),
+  "size": S.optionalWith(S.String, { nullable: true }),
+  "project_id": S.optionalWith(S.String, { nullable: true }),
+  "user_id": S.optionalWith(S.String, { nullable: true }),
+  "api_key_id": S.optionalWith(S.String, { nullable: true }),
+  "model": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageAudioSpeechesResultObject extends S.Literal("organization.usage.audio_speeches.result") {}
+
+export class UsageAudioSpeechesResult extends S.Struct({
+  "object": UsageAudioSpeechesResultObject,
+  "characters": S.Int,
+  "num_model_requests": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true }),
+  "user_id": S.optionalWith(S.String, { nullable: true }),
+  "api_key_id": S.optionalWith(S.String, { nullable: true }),
+  "model": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageAudioTranscriptionsResultObject extends S.Literal("organization.usage.audio_transcriptions.result") {}
+
+export class UsageAudioTranscriptionsResult extends S.Struct({
+  "object": UsageAudioTranscriptionsResultObject,
+  "seconds": S.Int,
+  "num_model_requests": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true }),
+  "user_id": S.optionalWith(S.String, { nullable: true }),
+  "api_key_id": S.optionalWith(S.String, { nullable: true }),
+  "model": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageVectorStoresResultObject extends S.Literal("organization.usage.vector_stores.result") {}
+
+export class UsageVectorStoresResult extends S.Struct({
+  "object": UsageVectorStoresResultObject,
+  "usage_bytes": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageCodeInterpreterSessionsResultObject
+  extends S.Literal("organization.usage.code_interpreter_sessions.result")
+{}
+
+export class UsageCodeInterpreterSessionsResult extends S.Struct({
+  "object": UsageCodeInterpreterSessionsResultObject,
+  "sessions": S.Int,
+  "project_id": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class CostsResultObject extends S.Literal("organization.costs.result") {}
+
+export class CostsResult extends S.Struct({
+  "object": CostsResultObject,
+  "amount": S.optionalWith(
+    S.Struct({
+      "value": S.optionalWith(S.Number, { nullable: true }),
+      "currency": S.optionalWith(S.String, { nullable: true })
+    }),
+    { nullable: true }
+  ),
+  "line_item": S.optionalWith(S.String, { nullable: true }),
+  "project_id": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageTimeBucket extends S.Struct({
+  "object": UsageTimeBucketObject,
+  "start_time": S.Int,
+  "end_time": S.Int,
+  "result": S.Array(
+    S.Union(
+      UsageCompletionsResult,
+      UsageEmbeddingsResult,
+      UsageModerationsResult,
+      UsageImagesResult,
+      UsageAudioSpeechesResult,
+      UsageAudioTranscriptionsResult,
+      UsageVectorStoresResult,
+      UsageCodeInterpreterSessionsResult,
+      CostsResult
+    )
+  )
+}) {}
+
+export class UsageResponse extends S.Class<UsageResponse>("UsageResponse")({
+  "object": UsageResponseObject,
+  "data": S.Array(UsageTimeBucket),
+  "has_more": S.Boolean,
+  "next_page": S.String
+}) {}
+
 export class ListInvitesParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
   "after": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class InviteListResponseObject extends S.Literal("list") {}
+
+export class InviteObject extends S.Literal("organization.invite") {}
+
+export class InviteRole extends S.Literal("owner", "reader") {}
+
+export class InviteStatus extends S.Literal("accepted", "expired", "pending") {}
+
+export class InviteProjectsRole extends S.Literal("member", "owner") {}
+
 export class Invite extends S.Struct({
-  "object": S.Literal("organization.invite"),
+  "object": InviteObject,
   "id": S.String,
   "email": S.String,
-  "role": S.Literal("owner", "reader"),
-  "status": S.Literal("accepted", "expired", "pending"),
+  "role": InviteRole,
+  "status": InviteStatus,
   "invited_at": S.Int,
   "expires_at": S.Int,
-  "accepted_at": S.optionalWith(S.Int, { nullable: true })
+  "accepted_at": S.optionalWith(S.Int, { nullable: true }),
+  "projects": S.optionalWith(
+    S.Array(S.Struct({
+      "id": S.optionalWith(S.String, { nullable: true }),
+      "role": S.optionalWith(InviteProjectsRole, { nullable: true })
+    })),
+    { nullable: true }
+  )
 }) {}
 
 export class InviteListResponse extends S.Class<InviteListResponse>("InviteListResponse")({
-  "object": S.Literal("list"),
+  "object": InviteListResponseObject,
   "data": S.Array(Invite),
   "first_id": S.optionalWith(S.String, { nullable: true }),
   "last_id": S.optionalWith(S.String, { nullable: true }),
   "has_more": S.optionalWith(S.Boolean, { nullable: true })
 }) {}
 
+export class InviteRequestRole extends S.Literal("reader", "owner") {}
+
+export class InviteRequestProjectsRole extends S.Literal("member", "owner") {}
+
 export class InviteRequest extends S.Class<InviteRequest>("InviteRequest")({
   "email": S.String,
-  "role": S.Literal("reader", "owner")
+  "role": InviteRequestRole,
+  "projects": S.optionalWith(
+    S.Array(S.Struct({
+      "id": S.String,
+      "role": InviteRequestProjectsRole
+    })),
+    { nullable: true }
+  )
 }) {}
 
+export class InviteDeleteResponseObject extends S.Literal("organization.invite.deleted") {}
+
 export class InviteDeleteResponse extends S.Class<InviteDeleteResponse>("InviteDeleteResponse")({
-  "object": S.Literal("organization.invite.deleted"),
+  "object": InviteDeleteResponseObject,
   "id": S.String,
   "deleted": S.Boolean
 }) {}
@@ -1424,17 +2037,23 @@ export class ListProjectsParams extends S.Struct({
   "include_archived": S.optionalWith(S.Boolean, { nullable: true, default: () => false as const })
 }) {}
 
+export class ProjectListResponseObject extends S.Literal("list") {}
+
+export class ProjectObject extends S.Literal("organization.project") {}
+
+export class ProjectStatus extends S.Literal("active", "archived") {}
+
 export class Project extends S.Struct({
   "id": S.String,
-  "object": S.Literal("organization.project"),
+  "object": ProjectObject,
   "name": S.String,
   "created_at": S.Int,
   "archived_at": S.optionalWith(S.Int, { nullable: true }),
-  "status": S.Literal("active", "archived")
+  "status": ProjectStatus
 }) {}
 
 export class ProjectListResponse extends S.Class<ProjectListResponse>("ProjectListResponse")({
-  "object": S.Literal("list"),
+  "object": ProjectListResponseObject,
   "data": S.Array(Project),
   "first_id": S.String,
   "last_id": S.String,
@@ -1465,58 +2084,119 @@ export class ListProjectApiKeysParams extends S.Struct({
   "after": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class ProjectApiKeyListResponseObject extends S.Literal("list") {}
+
+export class ProjectApiKeyObject extends S.Literal("organization.project.api_key") {}
+
+export class ProjectApiKeyOwnerType extends S.Literal("user", "service_account") {}
+
+export class ProjectUserObject extends S.Literal("organization.project.user") {}
+
+export class ProjectUserRole extends S.Literal("owner", "member") {}
+
 export class ProjectUser extends S.Struct({
-  "object": S.Literal("organization.project.user"),
+  "object": ProjectUserObject,
   "id": S.String,
   "name": S.String,
   "email": S.String,
-  "role": S.Literal("owner", "member"),
+  "role": ProjectUserRole,
   "added_at": S.Int
 }) {}
 
+export class ProjectServiceAccountObject extends S.Literal("organization.project.service_account") {}
+
+export class ProjectServiceAccountRole extends S.Literal("owner", "member") {}
+
 export class ProjectServiceAccount extends S.Struct({
-  "object": S.Literal("organization.project.service_account"),
+  "object": ProjectServiceAccountObject,
   "id": S.String,
   "name": S.String,
-  "role": S.Literal("owner", "member"),
+  "role": ProjectServiceAccountRole,
   "created_at": S.Int
 }) {}
 
 export class ProjectApiKey extends S.Struct({
-  "object": S.Literal("organization.project.api_key"),
+  "object": ProjectApiKeyObject,
   "redacted_value": S.String,
   "name": S.String,
   "created_at": S.Int,
   "id": S.String,
   "owner": S.Struct({
-    "type": S.optionalWith(S.Literal("user", "service_account"), { nullable: true }),
+    "type": S.optionalWith(ProjectApiKeyOwnerType, { nullable: true }),
     "user": S.optionalWith(ProjectUser, { nullable: true }),
     "service_account": S.optionalWith(ProjectServiceAccount, { nullable: true })
   })
 }) {}
 
 export class ProjectApiKeyListResponse extends S.Class<ProjectApiKeyListResponse>("ProjectApiKeyListResponse")({
-  "object": S.Literal("list"),
+  "object": ProjectApiKeyListResponseObject,
   "data": S.Array(ProjectApiKey),
   "first_id": S.String,
   "last_id": S.String,
   "has_more": S.Boolean
 }) {}
 
+export class ProjectApiKeyDeleteResponseObject extends S.Literal("organization.project.api_key.deleted") {}
+
 export class ProjectApiKeyDeleteResponse extends S.Class<ProjectApiKeyDeleteResponse>("ProjectApiKeyDeleteResponse")({
-  "object": S.Literal("organization.project.api_key.deleted"),
+  "object": ProjectApiKeyDeleteResponseObject,
   "id": S.String,
   "deleted": S.Boolean
 }) {}
 
+export class ListProjectRateLimitsParams extends S.Struct({
+  "limit": S.optionalWith(S.Int, { nullable: true, default: () => 100 as const }),
+  "after": S.optionalWith(S.String, { nullable: true }),
+  "before": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class ProjectRateLimitListResponseObject extends S.Literal("list") {}
+
+export class ProjectRateLimitObject extends S.Literal("project.rate_limit") {}
+
+export class ProjectRateLimit extends S.Struct({
+  "object": ProjectRateLimitObject,
+  "id": S.String,
+  "model": S.String,
+  "max_requests_per_1_minute": S.Int,
+  "max_tokens_per_1_minute": S.Int,
+  "max_images_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+  "max_audio_megabytes_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+  "max_requests_per_1_day": S.optionalWith(S.Int, { nullable: true }),
+  "batch_1_day_max_input_tokens": S.optionalWith(S.Int, { nullable: true })
+}) {}
+
+export class ProjectRateLimitListResponse
+  extends S.Class<ProjectRateLimitListResponse>("ProjectRateLimitListResponse")({
+    "object": ProjectRateLimitListResponseObject,
+    "data": S.Array(ProjectRateLimit),
+    "first_id": S.String,
+    "last_id": S.String,
+    "has_more": S.Boolean
+  })
+{}
+
+export class ProjectRateLimitUpdateRequest
+  extends S.Class<ProjectRateLimitUpdateRequest>("ProjectRateLimitUpdateRequest")({
+    "max_requests_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+    "max_tokens_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+    "max_images_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+    "max_audio_megabytes_per_1_minute": S.optionalWith(S.Int, { nullable: true }),
+    "max_requests_per_1_day": S.optionalWith(S.Int, { nullable: true }),
+    "batch_1_day_max_input_tokens": S.optionalWith(S.Int, { nullable: true })
+  })
+{}
+
 export class ListProjectServiceAccountsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
   "after": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class ProjectServiceAccountListResponseObject extends S.Literal("list") {}
+
 export class ProjectServiceAccountListResponse
   extends S.Class<ProjectServiceAccountListResponse>("ProjectServiceAccountListResponse")({
-    "object": S.Literal("list"),
+    "object": ProjectServiceAccountListResponseObject,
     "data": S.Array(ProjectServiceAccount),
     "first_id": S.String,
     "last_id": S.String,
@@ -1530,8 +2210,14 @@ export class ProjectServiceAccountCreateRequest
   })
 {}
 
+export class ProjectServiceAccountCreateResponseObject extends S.Literal("organization.project.service_account") {}
+
+export class ProjectServiceAccountCreateResponseRole extends S.Literal("member") {}
+
+export class ProjectServiceAccountApiKeyObject extends S.Literal("organization.project.service_account.api_key") {}
+
 export class ProjectServiceAccountApiKey extends S.Struct({
-  "object": S.Literal("organization.project.service_account.api_key"),
+  "object": ProjectServiceAccountApiKeyObject,
   "value": S.String,
   "name": S.String,
   "created_at": S.Int,
@@ -1540,18 +2226,22 @@ export class ProjectServiceAccountApiKey extends S.Struct({
 
 export class ProjectServiceAccountCreateResponse
   extends S.Class<ProjectServiceAccountCreateResponse>("ProjectServiceAccountCreateResponse")({
-    "object": S.Literal("organization.project.service_account"),
+    "object": ProjectServiceAccountCreateResponseObject,
     "id": S.String,
     "name": S.String,
-    "role": S.Literal("member"),
+    "role": ProjectServiceAccountCreateResponseRole,
     "created_at": S.Int,
     "api_key": ProjectServiceAccountApiKey
   })
 {}
 
+export class ProjectServiceAccountDeleteResponseObject
+  extends S.Literal("organization.project.service_account.deleted")
+{}
+
 export class ProjectServiceAccountDeleteResponse
   extends S.Class<ProjectServiceAccountDeleteResponse>("ProjectServiceAccountDeleteResponse")({
-    "object": S.Literal("organization.project.service_account.deleted"),
+    "object": ProjectServiceAccountDeleteResponseObject,
     "id": S.String,
     "deleted": S.Boolean
   })
@@ -1570,80 +2260,374 @@ export class ProjectUserListResponse extends S.Class<ProjectUserListResponse>("P
   "has_more": S.Boolean
 }) {}
 
+export class ProjectUserCreateRequestRole extends S.Literal("owner", "member") {}
+
 export class ProjectUserCreateRequest extends S.Class<ProjectUserCreateRequest>("ProjectUserCreateRequest")({
   "user_id": S.String,
-  "role": S.Literal("owner", "member")
+  "role": ProjectUserCreateRequestRole
 }) {}
 
+export class ProjectUserUpdateRequestRole extends S.Literal("owner", "member") {}
+
 export class ProjectUserUpdateRequest extends S.Class<ProjectUserUpdateRequest>("ProjectUserUpdateRequest")({
-  "role": S.Literal("owner", "member")
+  "role": ProjectUserUpdateRequestRole
 }) {}
 
+export class ProjectUserDeleteResponseObject extends S.Literal("organization.project.user.deleted") {}
+
 export class ProjectUserDeleteResponse extends S.Class<ProjectUserDeleteResponse>("ProjectUserDeleteResponse")({
-  "object": S.Literal("organization.project.user.deleted"),
+  "object": ProjectUserDeleteResponseObject,
   "id": S.String,
   "deleted": S.Boolean
 }) {}
 
+export class UsageAudioSpeechesParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageAudioSpeechesParamsGroupBy extends S.Literal("project_id", "user_id", "api_key_id", "model") {}
+
+export class UsageAudioSpeechesParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageAudioSpeechesParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "user_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "api_key_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "models": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageAudioSpeechesParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageAudioTranscriptionsParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageAudioTranscriptionsParamsGroupBy extends S.Literal("project_id", "user_id", "api_key_id", "model") {}
+
+export class UsageAudioTranscriptionsParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageAudioTranscriptionsParamsBucketWidth, {
+    nullable: true,
+    default: () => "1d" as const
+  }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "user_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "api_key_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "models": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageAudioTranscriptionsParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageCodeInterpreterSessionsParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageCodeInterpreterSessionsParamsGroupBy extends S.Literal("project_id") {}
+
+export class UsageCodeInterpreterSessionsParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageCodeInterpreterSessionsParamsBucketWidth, {
+    nullable: true,
+    default: () => "1d" as const
+  }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageCodeInterpreterSessionsParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageCompletionsParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageCompletionsParamsGroupBy extends S.Literal("project_id", "user_id", "api_key_id", "model", "batch") {}
+
+export class UsageCompletionsParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageCompletionsParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "user_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "api_key_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "models": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "batch": S.optionalWith(S.Boolean, { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageCompletionsParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageEmbeddingsParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageEmbeddingsParamsGroupBy extends S.Literal("project_id", "user_id", "api_key_id", "model") {}
+
+export class UsageEmbeddingsParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageEmbeddingsParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "user_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "api_key_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "models": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageEmbeddingsParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageImagesParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageImagesParamsSources extends S.Literal("image.generation", "image.edit", "image.variation") {}
+
+export class UsageImagesParamsSizes extends S.Literal("256x256", "512x512", "1024x1024", "1792x1792", "1024x1792") {}
+
+export class UsageImagesParamsGroupBy
+  extends S.Literal("project_id", "user_id", "api_key_id", "model", "size", "source")
+{}
+
+export class UsageImagesParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageImagesParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "sources": S.optionalWith(S.Array(UsageImagesParamsSources), { nullable: true }),
+  "sizes": S.optionalWith(S.Array(UsageImagesParamsSizes), { nullable: true }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "user_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "api_key_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "models": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageImagesParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageModerationsParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageModerationsParamsGroupBy extends S.Literal("project_id", "user_id", "api_key_id", "model") {}
+
+export class UsageModerationsParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageModerationsParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "user_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "api_key_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "models": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageModerationsParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class UsageVectorStoresParamsBucketWidth extends S.Literal("1m", "1h", "1d") {}
+
+export class UsageVectorStoresParamsGroupBy extends S.Literal("project_id") {}
+
+export class UsageVectorStoresParams extends S.Struct({
+  "start_time": S.Int,
+  "end_time": S.optionalWith(S.Int, { nullable: true }),
+  "bucket_width": S.optionalWith(UsageVectorStoresParamsBucketWidth, { nullable: true, default: () => "1d" as const }),
+  "project_ids": S.optionalWith(S.Array(S.String), { nullable: true }),
+  "group_by": S.optionalWith(S.Array(UsageVectorStoresParamsGroupBy), { nullable: true }),
+  "limit": S.optionalWith(S.Int, { nullable: true }),
+  "page": S.optionalWith(S.String, { nullable: true })
+}) {}
+
 export class ListUsersParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
   "after": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class UserListResponseObject extends S.Literal("list") {}
+
+export class UserObject extends S.Literal("organization.user") {}
+
+export class UserRole extends S.Literal("owner", "reader") {}
+
 export class User extends S.Struct({
-  "object": S.Literal("organization.user"),
+  "object": UserObject,
   "id": S.String,
   "name": S.String,
   "email": S.String,
-  "role": S.Literal("owner", "reader"),
+  "role": UserRole,
   "added_at": S.Int
 }) {}
 
 export class UserListResponse extends S.Class<UserListResponse>("UserListResponse")({
-  "object": S.Literal("list"),
+  "object": UserListResponseObject,
   "data": S.Array(User),
   "first_id": S.String,
   "last_id": S.String,
   "has_more": S.Boolean
 }) {}
 
+export class UserRoleUpdateRequestRole extends S.Literal("owner", "reader") {}
+
 export class UserRoleUpdateRequest extends S.Class<UserRoleUpdateRequest>("UserRoleUpdateRequest")({
-  "role": S.Literal("owner", "reader")
+  "role": UserRoleUpdateRequestRole
 }) {}
 
+export class UserDeleteResponseObject extends S.Literal("organization.user.deleted") {}
+
 export class UserDeleteResponse extends S.Class<UserDeleteResponse>("UserDeleteResponse")({
-  "object": S.Literal("organization.user.deleted"),
+  "object": UserDeleteResponseObject,
   "id": S.String,
   "deleted": S.Boolean
 }) {}
 
+export class RealtimeSessionCreateRequestModel extends S.Literal(
+  "gpt-4o-realtime-preview",
+  "gpt-4o-realtime-preview-2024-10-01",
+  "gpt-4o-realtime-preview-2024-12-17",
+  "gpt-4o-mini-realtime-preview",
+  "gpt-4o-mini-realtime-preview-2024-12-17"
+) {}
+
+export class RealtimeSessionCreateRequestVoice
+  extends S.Literal("alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse")
+{}
+
+export class RealtimeSessionCreateRequestInputAudioFormat extends S.Literal("pcm16", "g711_ulaw", "g711_alaw") {}
+
+export class RealtimeSessionCreateRequestOutputAudioFormat extends S.Literal("pcm16", "g711_ulaw", "g711_alaw") {}
+
+export class RealtimeSessionCreateRequestToolsType extends S.Literal("function") {}
+
+export class RealtimeSessionCreateRequestMaxResponseOutputTokens extends S.Literal("inf") {}
+
+export class RealtimeSessionCreateRequest
+  extends S.Class<RealtimeSessionCreateRequest>("RealtimeSessionCreateRequest")({
+    "model": S.optionalWith(RealtimeSessionCreateRequestModel, { nullable: true }),
+    "instructions": S.optionalWith(S.String, { nullable: true }),
+    "voice": S.optionalWith(RealtimeSessionCreateRequestVoice, { nullable: true }),
+    "input_audio_format": S.optionalWith(RealtimeSessionCreateRequestInputAudioFormat, { nullable: true }),
+    "output_audio_format": S.optionalWith(RealtimeSessionCreateRequestOutputAudioFormat, { nullable: true }),
+    "input_audio_transcription": S.optionalWith(
+      S.Struct({
+        "model": S.optionalWith(S.String, { nullable: true })
+      }),
+      { nullable: true }
+    ),
+    "turn_detection": S.optionalWith(
+      S.Struct({
+        "type": S.optionalWith(S.String, { nullable: true }),
+        "threshold": S.optionalWith(S.Number, { nullable: true }),
+        "prefix_padding_ms": S.optionalWith(S.Int, { nullable: true }),
+        "silence_duration_ms": S.optionalWith(S.Int, { nullable: true }),
+        "create_response": S.optionalWith(S.Boolean, { nullable: true, default: () => true as const })
+      }),
+      { nullable: true }
+    ),
+    "tools": S.optionalWith(
+      S.Array(S.Struct({
+        "type": S.optionalWith(RealtimeSessionCreateRequestToolsType, { nullable: true }),
+        "name": S.optionalWith(S.String, { nullable: true }),
+        "description": S.optionalWith(S.String, { nullable: true }),
+        "parameters": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
+      })),
+      { nullable: true }
+    ),
+    "tool_choice": S.optionalWith(S.String, { nullable: true }),
+    "temperature": S.optionalWith(S.Number, { nullable: true }),
+    "max_response_output_tokens": S.optionalWith(S.Union(S.Int, RealtimeSessionCreateRequestMaxResponseOutputTokens), {
+      nullable: true
+    })
+  })
+{}
+
+export class RealtimeSessionCreateResponseVoice
+  extends S.Literal("alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse")
+{}
+
+export class RealtimeSessionCreateResponseToolsType extends S.Literal("function") {}
+
+export class RealtimeSessionCreateResponseMaxResponseOutputTokens extends S.Literal("inf") {}
+
+export class RealtimeSessionCreateResponse
+  extends S.Class<RealtimeSessionCreateResponse>("RealtimeSessionCreateResponse")({
+    "client_secret": S.optionalWith(
+      S.Struct({
+        "value": S.optionalWith(S.String, { nullable: true }),
+        "expires_at": S.optionalWith(S.Int, { nullable: true })
+      }),
+      { nullable: true }
+    ),
+    "instructions": S.optionalWith(S.String, { nullable: true }),
+    "voice": S.optionalWith(RealtimeSessionCreateResponseVoice, { nullable: true }),
+    "input_audio_format": S.optionalWith(S.String, { nullable: true }),
+    "output_audio_format": S.optionalWith(S.String, { nullable: true }),
+    "input_audio_transcription": S.optionalWith(
+      S.Struct({
+        "model": S.optionalWith(S.String, { nullable: true })
+      }),
+      { nullable: true }
+    ),
+    "turn_detection": S.optionalWith(
+      S.Struct({
+        "type": S.optionalWith(S.String, { nullable: true }),
+        "threshold": S.optionalWith(S.Number, { nullable: true }),
+        "prefix_padding_ms": S.optionalWith(S.Int, { nullable: true }),
+        "silence_duration_ms": S.optionalWith(S.Int, { nullable: true })
+      }),
+      { nullable: true }
+    ),
+    "tools": S.optionalWith(
+      S.Array(S.Struct({
+        "type": S.optionalWith(RealtimeSessionCreateResponseToolsType, { nullable: true }),
+        "name": S.optionalWith(S.String, { nullable: true }),
+        "description": S.optionalWith(S.String, { nullable: true }),
+        "parameters": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
+      })),
+      { nullable: true }
+    ),
+    "tool_choice": S.optionalWith(S.String, { nullable: true }),
+    "temperature": S.optionalWith(S.Number, { nullable: true }),
+    "max_response_output_tokens": S.optionalWith(S.Union(S.Int, RealtimeSessionCreateResponseMaxResponseOutputTokens), {
+      nullable: true
+    })
+  })
+{}
+
+export class CreateMessageRequestRole extends S.Literal("user", "assistant") {}
+
+export class MessageContentImageFileObjectType extends S.Literal("image_file") {}
+
+export class MessageContentImageFileObjectImageFileDetail extends S.Literal("auto", "low", "high") {}
+
 export class MessageContentImageFileObject extends S.Struct({
-  "type": S.Literal("image_file"),
+  "type": MessageContentImageFileObjectType,
   "image_file": S.Struct({
     "file_id": S.String,
-    "detail": S.optionalWith(S.Literal("auto", "low", "high"), { nullable: true, default: () => "auto" as const })
+    "detail": S.optionalWith(MessageContentImageFileObjectImageFileDetail, {
+      nullable: true,
+      default: () => "auto" as const
+    })
   })
 }) {}
 
+export class MessageContentImageUrlObjectType extends S.Literal("image_url") {}
+
+export class MessageContentImageUrlObjectImageUrlDetail extends S.Literal("auto", "low", "high") {}
+
 export class MessageContentImageUrlObject extends S.Struct({
-  "type": S.Literal("image_url"),
+  "type": MessageContentImageUrlObjectType,
   "image_url": S.Struct({
     "url": S.String,
-    "detail": S.optionalWith(S.Literal("auto", "low", "high"), { nullable: true, default: () => "auto" as const })
+    "detail": S.optionalWith(MessageContentImageUrlObjectImageUrlDetail, {
+      nullable: true,
+      default: () => "auto" as const
+    })
   })
 }) {}
 
+export class MessageRequestContentTextObjectType extends S.Literal("text") {}
+
 export class MessageRequestContentTextObject extends S.Struct({
-  "type": S.Literal("text"),
+  "type": MessageRequestContentTextObjectType,
   "text": S.String
 }) {}
 
+export class AssistantToolsFileSearchTypeOnlyType extends S.Literal("file_search") {}
+
 export class AssistantToolsFileSearchTypeOnly extends S.Struct({
-  "type": S.Literal("file_search")
+  "type": AssistantToolsFileSearchTypeOnlyType
 }) {}
 
 export class CreateMessageRequest extends S.Struct({
-  "role": S.Literal("user", "assistant"),
+  "role": CreateMessageRequestRole,
   "content": S.Union(
     S.String,
     S.NonEmptyArray(
@@ -1662,6 +2646,8 @@ export class CreateMessageRequest extends S.Struct({
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class CreateThreadRequestToolResourcesFileSearchVectorStoresChunkingStrategyType extends S.Literal("static") {}
+
 export class CreateThreadRequest extends S.Class<CreateThreadRequest>("CreateThreadRequest")({
   "messages": S.optionalWith(S.Array(CreateMessageRequest), { nullable: true }),
   "tool_resources": S.optionalWith(
@@ -1695,9 +2681,11 @@ export class CreateThreadRequest extends S.Class<CreateThreadRequest>("CreateThr
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class ThreadObjectObject extends S.Literal("thread") {}
+
 export class ThreadObject extends S.Class<ThreadObject>("ThreadObject")({
   "id": S.String,
-  "object": S.Literal("thread"),
+  "object": ThreadObjectObject,
   "created_at": S.Int,
   "tool_resources": S.NullOr(S.Struct({
     "code_interpreter": S.optionalWith(
@@ -1719,13 +2707,44 @@ export class ThreadObject extends S.Class<ThreadObject>("ThreadObject")({
   "metadata": S.NullOr(S.Record({ key: S.String, value: S.Unknown }))
 }) {}
 
+export class CreateThreadAndRunRequestModel extends S.Literal(
+  "gpt-4o",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-0125-preview",
+  "gpt-4-turbo-preview",
+  "gpt-4-1106-preview",
+  "gpt-4-vision-preview",
+  "gpt-4",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-1106",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo-16k-0613"
+) {}
+
+export class TruncationObjectType extends S.Literal("auto", "last_messages") {}
+
 export class TruncationObject extends S.Struct({
-  "type": S.Literal("auto", "last_messages"),
+  "type": TruncationObjectType,
   "last_messages": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true })
 }) {}
 
+export class AssistantsNamedToolChoiceType extends S.Literal("function", "code_interpreter", "file_search") {}
+
 export class AssistantsNamedToolChoice extends S.Struct({
-  "type": S.Literal("function", "code_interpreter", "file_search"),
+  "type": AssistantsNamedToolChoiceType,
   "function": S.optionalWith(
     S.Struct({
       "name": S.String
@@ -1741,38 +2760,7 @@ export class AssistantsApiToolChoiceOption
 export class CreateThreadAndRunRequest extends S.Class<CreateThreadAndRunRequest>("CreateThreadAndRunRequest")({
   "assistant_id": S.String,
   "thread": S.optionalWith(CreateThreadRequest, { nullable: true }),
-  "model": S.optionalWith(
-    S.Union(
-      S.String,
-      S.Literal(
-        "gpt-4o",
-        "gpt-4o-2024-08-06",
-        "gpt-4o-2024-05-13",
-        "gpt-4o-2024-08-06",
-        "gpt-4o-mini",
-        "gpt-4o-mini-2024-07-18",
-        "gpt-4-turbo",
-        "gpt-4-turbo-2024-04-09",
-        "gpt-4-0125-preview",
-        "gpt-4-turbo-preview",
-        "gpt-4-1106-preview",
-        "gpt-4-vision-preview",
-        "gpt-4",
-        "gpt-4-0314",
-        "gpt-4-0613",
-        "gpt-4-32k",
-        "gpt-4-32k-0314",
-        "gpt-4-32k-0613",
-        "gpt-3.5-turbo",
-        "gpt-3.5-turbo-16k",
-        "gpt-3.5-turbo-0613",
-        "gpt-3.5-turbo-1106",
-        "gpt-3.5-turbo-0125",
-        "gpt-3.5-turbo-16k-0613"
-      )
-    ),
-    { nullable: true }
-  ),
+  "model": S.optionalWith(S.Union(S.String, CreateThreadAndRunRequestModel), { nullable: true }),
   "instructions": S.optionalWith(S.String, { nullable: true }),
   "tools": S.optionalWith(
     S.Array(S.Union(AssistantToolsCode, AssistantToolsFileSearch, AssistantToolsFunction)).pipe(S.maxItems(20)),
@@ -1816,15 +2804,37 @@ export class CreateThreadAndRunRequest extends S.Class<CreateThreadAndRunRequest
   "response_format": S.optionalWith(AssistantsApiResponseFormatOption, { nullable: true })
 }) {}
 
+export class RunObjectObject extends S.Literal("thread.run") {}
+
+export class RunObjectStatus extends S.Literal(
+  "queued",
+  "in_progress",
+  "requires_action",
+  "cancelling",
+  "cancelled",
+  "failed",
+  "completed",
+  "incomplete",
+  "expired"
+) {}
+
+export class RunObjectRequiredActionType extends S.Literal("submit_tool_outputs") {}
+
+export class RunToolCallObjectType extends S.Literal("function") {}
+
 export class RunToolCallObject extends S.Struct({
   "id": S.String,
-  "type": S.Literal("function"),
+  "type": RunToolCallObjectType,
   "function": S.Struct({
     "name": S.String,
     "arguments": S.String
   })
 }) {}
 
+export class RunObjectLastErrorCode extends S.Literal("server_error", "rate_limit_exceeded", "invalid_prompt") {}
+
+export class RunObjectIncompleteDetailsReason extends S.Literal("max_completion_tokens", "max_prompt_tokens") {}
+
 export class RunCompletionUsage extends S.Struct({
   "completion_tokens": S.Int,
   "prompt_tokens": S.Int,
@@ -1833,29 +2843,19 @@ export class RunCompletionUsage extends S.Struct({
 
 export class RunObject extends S.Class<RunObject>("RunObject")({
   "id": S.String,
-  "object": S.Literal("thread.run"),
+  "object": RunObjectObject,
   "created_at": S.Int,
   "thread_id": S.String,
   "assistant_id": S.String,
-  "status": S.Literal(
-    "queued",
-    "in_progress",
-    "requires_action",
-    "cancelling",
-    "cancelled",
-    "failed",
-    "completed",
-    "incomplete",
-    "expired"
-  ),
+  "status": RunObjectStatus,
   "required_action": S.NullOr(S.Struct({
-    "type": S.Literal("submit_tool_outputs"),
+    "type": RunObjectRequiredActionType,
     "submit_tool_outputs": S.Struct({
       "tool_calls": S.Array(RunToolCallObject)
     })
   })),
   "last_error": S.NullOr(S.Struct({
-    "code": S.Literal("server_error", "rate_limit_exceeded", "invalid_prompt"),
+    "code": RunObjectLastErrorCode,
     "message": S.String
   })),
   "expires_at": S.NullOr(S.Int),
@@ -1864,7 +2864,7 @@ export class RunObject extends S.Class<RunObject>("RunObject")({
   "failed_at": S.NullOr(S.Int),
   "completed_at": S.NullOr(S.Int),
   "incomplete_details": S.NullOr(S.Struct({
-    "reason": S.optionalWith(S.Literal("max_completion_tokens", "max_prompt_tokens"), { nullable: true })
+    "reason": S.optionalWith(RunObjectIncompleteDetailsReason, { nullable: true })
   })),
   "model": S.String,
   "instructions": S.String,
@@ -1906,22 +2906,40 @@ export class ModifyThreadRequest extends S.Class<ModifyThreadRequest>("ModifyThr
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class DeleteThreadResponseObject extends S.Literal("thread.deleted") {}
+
 export class DeleteThreadResponse extends S.Class<DeleteThreadResponse>("DeleteThreadResponse")({
   "id": S.String,
   "deleted": S.Boolean,
-  "object": S.Literal("thread.deleted")
+  "object": DeleteThreadResponseObject
 }) {}
 
+export class ListMessagesParamsOrder extends S.Literal("asc", "desc") {}
+
 export class ListMessagesParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListMessagesParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true }),
   "run_id": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class MessageObjectObject extends S.Literal("thread.message") {}
+
+export class MessageObjectStatus extends S.Literal("in_progress", "incomplete", "completed") {}
+
+export class MessageObjectIncompleteDetailsReason
+  extends S.Literal("content_filter", "max_tokens", "run_cancelled", "run_expired", "run_failed")
+{}
+
+export class MessageObjectRole extends S.Literal("user", "assistant") {}
+
+export class MessageContentTextObjectType extends S.Literal("text") {}
+
+export class MessageContentTextAnnotationsFileCitationObjectType extends S.Literal("file_citation") {}
+
 export class MessageContentTextAnnotationsFileCitationObject extends S.Struct({
-  "type": S.Literal("file_citation"),
+  "type": MessageContentTextAnnotationsFileCitationObjectType,
   "text": S.String,
   "file_citation": S.Struct({
     "file_id": S.String
@@ -1930,8 +2948,10 @@ export class MessageContentTextAnnotationsFileCitationObject extends S.Struct({
   "end_index": S.Int.pipe(S.greaterThanOrEqualTo(0))
 }) {}
 
+export class MessageContentTextAnnotationsFilePathObjectType extends S.Literal("file_path") {}
+
 export class MessageContentTextAnnotationsFilePathObject extends S.Struct({
-  "type": S.Literal("file_path"),
+  "type": MessageContentTextAnnotationsFilePathObjectType,
   "text": S.String,
   "file_path": S.Struct({
     "file_id": S.String
@@ -1941,7 +2961,7 @@ export class MessageContentTextAnnotationsFilePathObject extends S.Struct({
 }) {}
 
 export class MessageContentTextObject extends S.Struct({
-  "type": S.Literal("text"),
+  "type": MessageContentTextObjectType,
   "text": S.Struct({
     "value": S.String,
     "annotations": S.Array(
@@ -1950,23 +2970,25 @@ export class MessageContentTextObject extends S.Struct({
   })
 }) {}
 
+export class MessageContentRefusalObjectType extends S.Literal("refusal") {}
+
 export class MessageContentRefusalObject extends S.Struct({
-  "type": S.Literal("refusal"),
+  "type": MessageContentRefusalObjectType,
   "refusal": S.String
 }) {}
 
 export class MessageObject extends S.Struct({
   "id": S.String,
-  "object": S.Literal("thread.message"),
+  "object": MessageObjectObject,
   "created_at": S.Int,
   "thread_id": S.String,
-  "status": S.Literal("in_progress", "incomplete", "completed"),
+  "status": MessageObjectStatus,
   "incomplete_details": S.NullOr(S.Struct({
-    "reason": S.Literal("content_filter", "max_tokens", "run_cancelled", "run_expired", "run_failed")
+    "reason": MessageObjectIncompleteDetailsReason
   })),
   "completed_at": S.NullOr(S.Int),
   "incomplete_at": S.NullOr(S.Int),
-  "role": S.Literal("user", "assistant"),
+  "role": MessageObjectRole,
   "content": S.Array(
     S.Union(
       MessageContentImageFileObject,
@@ -1996,15 +3018,19 @@ export class ModifyMessageRequest extends S.Class<ModifyMessageRequest>("ModifyM
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class DeleteMessageResponseObject extends S.Literal("thread.message.deleted") {}
+
 export class DeleteMessageResponse extends S.Class<DeleteMessageResponse>("DeleteMessageResponse")({
   "id": S.String,
   "deleted": S.Boolean,
-  "object": S.Literal("thread.message.deleted")
+  "object": DeleteMessageResponseObject
 }) {}
 
+export class ListRunsParamsOrder extends S.Literal("asc", "desc") {}
+
 export class ListRunsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListRunsParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true })
 }) {}
@@ -2017,46 +3043,42 @@ export class ListRunsResponse extends S.Class<ListRunsResponse>("ListRunsRespons
   "has_more": S.Boolean
 }) {}
 
+export class CreateRunParamsInclude extends S.Literal("step_details.tool_calls[*].file_search.results[*].content") {}
+
 export class CreateRunParams extends S.Struct({
-  "include[]": S.optionalWith(S.Array(S.Literal("step_details.tool_calls[*].file_search.results[*].content")), {
-    nullable: true
-  })
-}) {}
+  "include[]": S.optionalWith(S.Array(CreateRunParamsInclude), { nullable: true })
+}) {}
+
+export class CreateRunRequestModel extends S.Literal(
+  "gpt-4o",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-0125-preview",
+  "gpt-4-turbo-preview",
+  "gpt-4-1106-preview",
+  "gpt-4-vision-preview",
+  "gpt-4",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-1106",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo-16k-0613"
+) {}
 
 export class CreateRunRequest extends S.Class<CreateRunRequest>("CreateRunRequest")({
   "assistant_id": S.String,
-  "model": S.optionalWith(
-    S.Union(
-      S.String,
-      S.Literal(
-        "gpt-4o",
-        "gpt-4o-2024-08-06",
-        "gpt-4o-2024-05-13",
-        "gpt-4o-2024-08-06",
-        "gpt-4o-mini",
-        "gpt-4o-mini-2024-07-18",
-        "gpt-4-turbo",
-        "gpt-4-turbo-2024-04-09",
-        "gpt-4-0125-preview",
-        "gpt-4-turbo-preview",
-        "gpt-4-1106-preview",
-        "gpt-4-vision-preview",
-        "gpt-4",
-        "gpt-4-0314",
-        "gpt-4-0613",
-        "gpt-4-32k",
-        "gpt-4-32k-0314",
-        "gpt-4-32k-0613",
-        "gpt-3.5-turbo",
-        "gpt-3.5-turbo-16k",
-        "gpt-3.5-turbo-0613",
-        "gpt-3.5-turbo-1106",
-        "gpt-3.5-turbo-0125",
-        "gpt-3.5-turbo-16k-0613"
-      )
-    ),
-    { nullable: true }
-  ),
+  "model": S.optionalWith(S.Union(S.String, CreateRunRequestModel), { nullable: true }),
   "instructions": S.optionalWith(S.String, { nullable: true }),
   "additional_instructions": S.optionalWith(S.String, { nullable: true }),
   "additional_messages": S.optionalWith(S.Array(CreateMessageRequest), { nullable: true }),
@@ -2086,30 +3108,48 @@ export class ModifyRunRequest extends S.Class<ModifyRunRequest>("ModifyRunReques
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class ListRunStepsParamsOrder extends S.Literal("asc", "desc") {}
+
+export class ListRunStepsParamsInclude extends S.Literal("step_details.tool_calls[*].file_search.results[*].content") {}
+
 export class ListRunStepsParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListRunStepsParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true }),
-  "include[]": S.optionalWith(S.Array(S.Literal("step_details.tool_calls[*].file_search.results[*].content")), {
-    nullable: true
-  })
+  "include[]": S.optionalWith(S.Array(ListRunStepsParamsInclude), { nullable: true })
 }) {}
 
+export class RunStepObjectObject extends S.Literal("thread.run.step") {}
+
+export class RunStepObjectType extends S.Literal("message_creation", "tool_calls") {}
+
+export class RunStepObjectStatus extends S.Literal("in_progress", "cancelled", "failed", "completed", "expired") {}
+
+export class RunStepDetailsMessageCreationObjectType extends S.Literal("message_creation") {}
+
 export class RunStepDetailsMessageCreationObject extends S.Struct({
-  "type": S.Literal("message_creation"),
+  "type": RunStepDetailsMessageCreationObjectType,
   "message_creation": S.Struct({
     "message_id": S.String
   })
 }) {}
 
+export class RunStepDetailsToolCallsObjectType extends S.Literal("tool_calls") {}
+
+export class RunStepDetailsToolCallsCodeObjectType extends S.Literal("code_interpreter") {}
+
+export class RunStepDetailsToolCallsCodeOutputLogsObjectType extends S.Literal("logs") {}
+
 export class RunStepDetailsToolCallsCodeOutputLogsObject extends S.Struct({
-  "type": S.Literal("logs"),
+  "type": RunStepDetailsToolCallsCodeOutputLogsObjectType,
   "logs": S.String
 }) {}
 
+export class RunStepDetailsToolCallsCodeOutputImageObjectType extends S.Literal("image") {}
+
 export class RunStepDetailsToolCallsCodeOutputImageObject extends S.Struct({
-  "type": S.Literal("image"),
+  "type": RunStepDetailsToolCallsCodeOutputImageObjectType,
   "image": S.Struct({
     "file_id": S.String
   })
@@ -2117,25 +3157,31 @@ export class RunStepDetailsToolCallsCodeOutputImageObject extends S.Struct({
 
 export class RunStepDetailsToolCallsCodeObject extends S.Struct({
   "id": S.String,
-  "type": S.Literal("code_interpreter"),
+  "type": RunStepDetailsToolCallsCodeObjectType,
   "code_interpreter": S.Struct({
     "input": S.String,
     "outputs": S.Array(S.Record({ key: S.String, value: S.Unknown }))
   })
 }) {}
 
+export class RunStepDetailsToolCallsFileSearchObjectType extends S.Literal("file_search") {}
+
+export class RunStepDetailsToolCallsFileSearchRankingOptionsObjectRanker extends S.Literal("default_2024_08_21") {}
+
 export class RunStepDetailsToolCallsFileSearchRankingOptionsObject extends S.Struct({
-  "ranker": S.Literal("default_2024_08_21"),
+  "ranker": RunStepDetailsToolCallsFileSearchRankingOptionsObjectRanker,
   "score_threshold": S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1))
 }) {}
 
+export class RunStepDetailsToolCallsFileSearchResultObjectContentType extends S.Literal("text") {}
+
 export class RunStepDetailsToolCallsFileSearchResultObject extends S.Struct({
   "file_id": S.String,
   "file_name": S.String,
   "score": S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)),
   "content": S.optionalWith(
     S.Array(S.Struct({
-      "type": S.optionalWith(S.Literal("text"), { nullable: true }),
+      "type": S.optionalWith(RunStepDetailsToolCallsFileSearchResultObjectContentType, { nullable: true }),
       "text": S.optionalWith(S.String, { nullable: true })
     })),
     { nullable: true }
@@ -2144,16 +3190,18 @@ export class RunStepDetailsToolCallsFileSearchResultObject extends S.Struct({
 
 export class RunStepDetailsToolCallsFileSearchObject extends S.Struct({
   "id": S.String,
-  "type": S.Literal("file_search"),
+  "type": RunStepDetailsToolCallsFileSearchObjectType,
   "file_search": S.Struct({
     "ranking_options": S.optionalWith(RunStepDetailsToolCallsFileSearchRankingOptionsObject, { nullable: true }),
     "results": S.optionalWith(S.Array(RunStepDetailsToolCallsFileSearchResultObject), { nullable: true })
   })
 }) {}
 
+export class RunStepDetailsToolCallsFunctionObjectType extends S.Literal("function") {}
+
 export class RunStepDetailsToolCallsFunctionObject extends S.Struct({
   "id": S.String,
-  "type": S.Literal("function"),
+  "type": RunStepDetailsToolCallsFunctionObjectType,
   "function": S.Struct({
     "name": S.String,
     "arguments": S.String,
@@ -2162,7 +3210,7 @@ export class RunStepDetailsToolCallsFunctionObject extends S.Struct({
 }) {}
 
 export class RunStepDetailsToolCallsObject extends S.Struct({
-  "type": S.Literal("tool_calls"),
+  "type": RunStepDetailsToolCallsObjectType,
   "tool_calls": S.Array(
     S.Union(
       RunStepDetailsToolCallsCodeObject,
@@ -2172,6 +3220,8 @@ export class RunStepDetailsToolCallsObject extends S.Struct({
   )
 }) {}
 
+export class RunStepObjectLastErrorCode extends S.Literal("server_error", "rate_limit_exceeded") {}
+
 export class RunStepCompletionUsage extends S.Struct({
   "completion_tokens": S.Int,
   "prompt_tokens": S.Int,
@@ -2180,16 +3230,16 @@ export class RunStepCompletionUsage extends S.Struct({
 
 export class RunStepObject extends S.Struct({
   "id": S.String,
-  "object": S.Literal("thread.run.step"),
+  "object": RunStepObjectObject,
   "created_at": S.Int,
   "assistant_id": S.String,
   "thread_id": S.String,
   "run_id": S.String,
-  "type": S.Literal("message_creation", "tool_calls"),
-  "status": S.Literal("in_progress", "cancelled", "failed", "completed", "expired"),
+  "type": RunStepObjectType,
+  "status": RunStepObjectStatus,
   "step_details": S.Record({ key: S.String, value: S.Unknown }),
   "last_error": S.NullOr(S.Struct({
-    "code": S.Literal("server_error", "rate_limit_exceeded"),
+    "code": RunStepObjectLastErrorCode,
     "message": S.String
   })),
   "expired_at": S.NullOr(S.Int),
@@ -2208,10 +3258,10 @@ export class ListRunStepsResponse extends S.Class<ListRunStepsResponse>("ListRun
   "has_more": S.Boolean
 }) {}
 
+export class GetRunStepParamsInclude extends S.Literal("step_details.tool_calls[*].file_search.results[*].content") {}
+
 export class GetRunStepParams extends S.Struct({
-  "include[]": S.optionalWith(S.Array(S.Literal("step_details.tool_calls[*].file_search.results[*].content")), {
-    nullable: true
-  })
+  "include[]": S.optionalWith(S.Array(GetRunStepParamsInclude), { nullable: true })
 }) {}
 
 export class SubmitToolOutputsRunRequest extends S.Class<SubmitToolOutputsRunRequest>("SubmitToolOutputsRunRequest")({
@@ -2222,22 +3272,28 @@ export class SubmitToolOutputsRunRequest extends S.Class<SubmitToolOutputsRunReq
   "stream": S.optionalWith(S.Boolean, { nullable: true })
 }) {}
 
+export class CreateUploadRequestPurpose extends S.Literal("assistants", "batch", "fine-tune", "vision") {}
+
 export class CreateUploadRequest extends S.Class<CreateUploadRequest>("CreateUploadRequest")({
   "filename": S.String,
-  "purpose": S.Literal("assistants", "batch", "fine-tune", "vision"),
+  "purpose": CreateUploadRequestPurpose,
   "bytes": S.Int,
   "mime_type": S.String
 }) {}
 
+export class UploadStatus extends S.Literal("pending", "completed", "cancelled", "expired") {}
+
+export class UploadObject extends S.Literal("upload") {}
+
 export class Upload extends S.Class<Upload>("Upload")({
   "id": S.String,
   "created_at": S.Int,
   "filename": S.String,
   "bytes": S.Int,
   "purpose": S.String,
-  "status": S.Literal("pending", "completed", "cancelled", "expired"),
+  "status": UploadStatus,
   "expires_at": S.Int,
-  "object": S.optionalWith(S.Literal("upload"), { nullable: true }),
+  "object": S.optionalWith(UploadObject, { nullable: true }),
   "file": S.optionalWith(OpenAIFile, { nullable: true })
 }) {}
 
@@ -2246,28 +3302,38 @@ export class CompleteUploadRequest extends S.Class<CompleteUploadRequest>("Compl
   "md5": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class UploadPartObject extends S.Literal("upload.part") {}
+
 export class UploadPart extends S.Class<UploadPart>("UploadPart")({
   "id": S.String,
   "created_at": S.Int,
   "upload_id": S.String,
-  "object": S.Literal("upload.part")
+  "object": UploadPartObject
 }) {}
 
+export class ListVectorStoresParamsOrder extends S.Literal("asc", "desc") {}
+
 export class ListVectorStoresParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListVectorStoresParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true })
 }) {}
 
+export class VectorStoreObjectObject extends S.Literal("vector_store") {}
+
+export class VectorStoreObjectStatus extends S.Literal("expired", "in_progress", "completed") {}
+
+export class VectorStoreExpirationAfterAnchor extends S.Literal("last_active_at") {}
+
 export class VectorStoreExpirationAfter extends S.Struct({
-  "anchor": S.Literal("last_active_at"),
+  "anchor": VectorStoreExpirationAfterAnchor,
   "days": S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(365))
 }) {}
 
 export class VectorStoreObject extends S.Struct({
   "id": S.String,
-  "object": S.Literal("vector_store"),
+  "object": VectorStoreObjectObject,
   "created_at": S.Int,
   "name": S.String,
   "usage_bytes": S.Int,
@@ -2278,7 +3344,7 @@ export class VectorStoreObject extends S.Struct({
     "cancelled": S.Int,
     "total": S.Int
   }),
-  "status": S.Literal("expired", "in_progress", "completed"),
+  "status": VectorStoreObjectStatus,
   "expires_after": S.optionalWith(VectorStoreExpirationAfter, { nullable: true }),
   "expires_at": S.optionalWith(S.Int, { nullable: true }),
   "last_active_at": S.NullOr(S.Int),
@@ -2293,17 +3359,21 @@ export class ListVectorStoresResponse extends S.Class<ListVectorStoresResponse>(
   "has_more": S.Boolean
 }) {}
 
+export class AutoChunkingStrategyRequestParamType extends S.Literal("auto") {}
+
 export class AutoChunkingStrategyRequestParam extends S.Struct({
-  "type": S.Literal("auto")
+  "type": AutoChunkingStrategyRequestParamType
 }) {}
 
+export class StaticChunkingStrategyRequestParamType extends S.Literal("static") {}
+
 export class StaticChunkingStrategy extends S.Struct({
   "max_chunk_size_tokens": S.Int.pipe(S.greaterThanOrEqualTo(100), S.lessThanOrEqualTo(4096)),
   "chunk_overlap_tokens": S.Int
 }) {}
 
 export class StaticChunkingStrategyRequestParam extends S.Struct({
-  "type": S.Literal("static"),
+  "type": StaticChunkingStrategyRequestParamType,
   "static": StaticChunkingStrategy
 }) {}
 
@@ -2321,10 +3391,12 @@ export class UpdateVectorStoreRequest extends S.Class<UpdateVectorStoreRequest>(
   "metadata": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
 }) {}
 
+export class DeleteVectorStoreResponseObject extends S.Literal("vector_store.deleted") {}
+
 export class DeleteVectorStoreResponse extends S.Class<DeleteVectorStoreResponse>("DeleteVectorStoreResponse")({
   "id": S.String,
   "deleted": S.Boolean,
-  "object": S.Literal("vector_store.deleted")
+  "object": DeleteVectorStoreResponseObject
 }) {}
 
 export class ChunkingStrategyRequestParam extends S.Record({ key: S.String, value: S.Unknown }) {}
@@ -2336,12 +3408,16 @@ export class CreateVectorStoreFileBatchRequest
   })
 {}
 
+export class VectorStoreFileBatchObjectObject extends S.Literal("vector_store.files_batch") {}
+
+export class VectorStoreFileBatchObjectStatus extends S.Literal("in_progress", "completed", "cancelled", "failed") {}
+
 export class VectorStoreFileBatchObject extends S.Class<VectorStoreFileBatchObject>("VectorStoreFileBatchObject")({
   "id": S.String,
-  "object": S.Literal("vector_store.files_batch"),
+  "object": VectorStoreFileBatchObjectObject,
   "created_at": S.Int,
   "vector_store_id": S.String,
-  "status": S.Literal("in_progress", "completed", "cancelled", "failed"),
+  "status": VectorStoreFileBatchObjectStatus,
   "file_counts": S.Struct({
     "in_progress": S.Int,
     "completed": S.Int,
@@ -2351,32 +3427,48 @@ export class VectorStoreFileBatchObject extends S.Class<VectorStoreFileBatchObje
   })
 }) {}
 
+export class ListFilesInVectorStoreBatchParamsOrder extends S.Literal("asc", "desc") {}
+
+export class ListFilesInVectorStoreBatchParamsFilter
+  extends S.Literal("in_progress", "completed", "failed", "cancelled")
+{}
+
 export class ListFilesInVectorStoreBatchParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListFilesInVectorStoreBatchParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true }),
-  "filter": S.optionalWith(S.Literal("in_progress", "completed", "failed", "cancelled"), { nullable: true })
+  "filter": S.optionalWith(ListFilesInVectorStoreBatchParamsFilter, { nullable: true })
 }) {}
 
+export class VectorStoreFileObjectObject extends S.Literal("vector_store.file") {}
+
+export class VectorStoreFileObjectStatus extends S.Literal("in_progress", "completed", "cancelled", "failed") {}
+
+export class VectorStoreFileObjectLastErrorCode extends S.Literal("server_error", "unsupported_file", "invalid_file") {}
+
+export class StaticChunkingStrategyResponseParamType extends S.Literal("static") {}
+
 export class StaticChunkingStrategyResponseParam extends S.Struct({
-  "type": S.Literal("static"),
+  "type": StaticChunkingStrategyResponseParamType,
   "static": StaticChunkingStrategy
 }) {}
 
+export class OtherChunkingStrategyResponseParamType extends S.Literal("other") {}
+
 export class OtherChunkingStrategyResponseParam extends S.Struct({
-  "type": S.Literal("other")
+  "type": OtherChunkingStrategyResponseParamType
 }) {}
 
 export class VectorStoreFileObject extends S.Struct({
   "id": S.String,
-  "object": S.Literal("vector_store.file"),
+  "object": VectorStoreFileObjectObject,
   "usage_bytes": S.Int,
   "created_at": S.Int,
   "vector_store_id": S.String,
-  "status": S.Literal("in_progress", "completed", "cancelled", "failed"),
+  "status": VectorStoreFileObjectStatus,
   "last_error": S.NullOr(S.Struct({
-    "code": S.Literal("server_error", "unsupported_file", "invalid_file"),
+    "code": VectorStoreFileObjectLastErrorCode,
     "message": S.String
   })),
   "chunking_strategy": S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true })
@@ -2392,12 +3484,16 @@ export class ListVectorStoreFilesResponse
   })
 {}
 
+export class ListVectorStoreFilesParamsOrder extends S.Literal("asc", "desc") {}
+
+export class ListVectorStoreFilesParamsFilter extends S.Literal("in_progress", "completed", "failed", "cancelled") {}
+
 export class ListVectorStoreFilesParams extends S.Struct({
   "limit": S.optionalWith(S.Int, { nullable: true, default: () => 20 as const }),
-  "order": S.optionalWith(S.Literal("asc", "desc"), { nullable: true, default: () => "desc" as const }),
+  "order": S.optionalWith(ListVectorStoreFilesParamsOrder, { nullable: true, default: () => "desc" as const }),
   "after": S.optionalWith(S.String, { nullable: true }),
   "before": S.optionalWith(S.String, { nullable: true }),
-  "filter": S.optionalWith(S.Literal("in_progress", "completed", "failed", "cancelled"), { nullable: true })
+  "filter": S.optionalWith(ListVectorStoreFilesParamsFilter, { nullable: true })
 }) {}
 
 export class CreateVectorStoreFileRequest
@@ -2407,11 +3503,13 @@ export class CreateVectorStoreFileRequest
   })
 {}
 
+export class DeleteVectorStoreFileResponseObject extends S.Literal("vector_store.file.deleted") {}
+
 export class DeleteVectorStoreFileResponse
   extends S.Class<DeleteVectorStoreFileResponse>("DeleteVectorStoreFileResponse")({
     "id": S.String,
     "deleted": S.Boolean,
-    "object": S.Literal("vector_store.file.deleted")
+    "object": DeleteVectorStoreFileResponseObject
   })
 {}
 
@@ -2655,7 +3753,12 @@ export const make = (httpClient: HttpClient.HttpClient): Client => {
       ),
     "listFiles": (options) =>
       HttpClientRequest.make("GET")(`/files`).pipe(
-        HttpClientRequest.setUrlParams({ "purpose": options["purpose"] }),
+        HttpClientRequest.setUrlParams({
+          "purpose": options["purpose"],
+          "limit": options["limit"],
+          "order": options["order"],
+          "after": options["after"]
+        }),
         Effect.succeed,
         Effect.flatMap((request) =>
           Effect.flatMap(
@@ -2912,6 +4015,67 @@ export const make = (httpClient: HttpClient.HttpClient): Client => {
         ),
         Effect.scoped
       ),
+    "adminApiKeysList": (options) =>
+      HttpClientRequest.make("GET")(`/organization/admin_api_keys`).pipe(
+        HttpClientRequest.setUrlParams({
+          "after": options["after"],
+          "order": options["order"],
+          "limit": options["limit"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(ApiKeyList)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "adminApiKeysCreate": (options) =>
+      HttpClientRequest.make("POST")(`/organization/admin_api_keys`).pipe(
+        (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options)),
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(AdminApiKey)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "adminApiKeysGet": (keyId) =>
+      HttpClientRequest.make("GET")(`/organization/admin_api_keys/${keyId}`).pipe(
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(AdminApiKey)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "adminApiKeysDelete": (keyId) =>
+      HttpClientRequest.make("DELETE")(`/organization/admin_api_keys/${keyId}`).pipe(
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(AdminApiKeysDelete200)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
     "listAuditLogs": (options) =>
       HttpClientRequest.make("GET")(`/organization/audit_logs`).pipe(
         HttpClientRequest.setUrlParams({
@@ -2940,6 +4104,29 @@ export const make = (httpClient: HttpClient.HttpClient): Client => {
         ),
         Effect.scoped
       ),
+    "usageCosts": (options) =>
+      HttpClientRequest.make("GET")(`/organization/costs`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
     "listInvites": (options) =>
       HttpClientRequest.make("GET")(`/organization/invites`).pipe(
         HttpClientRequest.setUrlParams({ "limit": options["limit"], "after": options["after"] }),
@@ -3117,6 +4304,40 @@ export const make = (httpClient: HttpClient.HttpClient): Client => {
         ),
         Effect.scoped
       ),
+    "listProjectRateLimits": (projectId, options) =>
+      HttpClientRequest.make("GET")(`/organization/projects/${projectId}/rate_limits`).pipe(
+        HttpClientRequest.setUrlParams({
+          "limit": options["limit"],
+          "after": options["after"],
+          "before": options["before"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(ProjectRateLimitListResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "updateProjectRateLimits": (projectId, rateLimitId, options) =>
+      HttpClientRequest.make("POST")(`/organization/projects/${projectId}/rate_limits/${rateLimitId}`).pipe(
+        (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options)),
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(ProjectRateLimit)(r),
+              "400": (r) => decodeError(r, ErrorResponse),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
     "listProjectServiceAccounts": (projectId, options) =>
       HttpClientRequest.make("GET")(`/organization/projects/${projectId}/service_accounts`).pipe(
         HttpClientRequest.setUrlParams({ "limit": options["limit"], "after": options["after"] }),
@@ -3251,6 +4472,211 @@ export const make = (httpClient: HttpClient.HttpClient): Client => {
         ),
         Effect.scoped
       ),
+    "usageAudioSpeeches": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/audio_speeches`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "user_ids": options["user_ids"],
+          "api_key_ids": options["api_key_ids"],
+          "models": options["models"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageAudioTranscriptions": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/audio_transcriptions`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "user_ids": options["user_ids"],
+          "api_key_ids": options["api_key_ids"],
+          "models": options["models"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageCodeInterpreterSessions": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/code_interpreter_sessions`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageCompletions": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/completions`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "user_ids": options["user_ids"],
+          "api_key_ids": options["api_key_ids"],
+          "models": options["models"],
+          "batch": options["batch"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageEmbeddings": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/embeddings`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "user_ids": options["user_ids"],
+          "api_key_ids": options["api_key_ids"],
+          "models": options["models"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageImages": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/images`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "sources": options["sources"],
+          "sizes": options["sizes"],
+          "project_ids": options["project_ids"],
+          "user_ids": options["user_ids"],
+          "api_key_ids": options["api_key_ids"],
+          "models": options["models"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageModerations": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/moderations`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "user_ids": options["user_ids"],
+          "api_key_ids": options["api_key_ids"],
+          "models": options["models"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
+    "usageVectorStores": (options) =>
+      HttpClientRequest.make("GET")(`/organization/usage/vector_stores`).pipe(
+        HttpClientRequest.setUrlParams({
+          "start_time": options["start_time"],
+          "end_time": options["end_time"],
+          "bucket_width": options["bucket_width"],
+          "project_ids": options["project_ids"],
+          "group_by": options["group_by"],
+          "limit": options["limit"],
+          "page": options["page"]
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(UsageResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
     "listUsers": (options) =>
       HttpClientRequest.make("GET")(`/organization/users`).pipe(
         HttpClientRequest.setUrlParams({ "limit": options["limit"], "after": options["after"] }),
@@ -3308,6 +4734,20 @@ export const make = (httpClient: HttpClient.HttpClient): Client => {
         ),
         Effect.scoped
       ),
+    "createRealtimeSession": (options) =>
+      HttpClientRequest.make("POST")(`/realtime/sessions`).pipe(
+        (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options)),
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            httpClient.execute(request),
+            HttpClientResponse.matchStatus({
+              "200": (r) => HttpClientResponse.schemaBodyJson(RealtimeSessionCreateResponse)(r),
+              orElse: (response) => unexpectedStatus(request, response)
+            })
+          )
+        ),
+        Effect.scoped
+      ),
     "createThread": (options) =>
       HttpClientRequest.make("POST")(`/threads`).pipe(
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options)),
@@ -3948,9 +5388,24 @@ export interface Client {
   readonly "createModeration": (
     options: typeof CreateModerationRequest.Encoded
   ) => Effect.Effect<typeof CreateModerationResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "adminApiKeysList": (
+    options: typeof AdminApiKeysListParams.Encoded
+  ) => Effect.Effect<typeof ApiKeyList.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "adminApiKeysCreate": (
+    options: typeof AdminApiKeysCreateRequest.Encoded
+  ) => Effect.Effect<typeof AdminApiKey.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "adminApiKeysGet": (
+    keyId: string
+  ) => Effect.Effect<typeof AdminApiKey.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "adminApiKeysDelete": (
+    keyId: string
+  ) => Effect.Effect<typeof AdminApiKeysDelete200.Type, HttpClientError.HttpClientError | ParseError>
   readonly "listAuditLogs": (
     options: typeof ListAuditLogsParams.Encoded
   ) => Effect.Effect<typeof ListAuditLogsResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageCosts": (
+    options: typeof UsageCostsParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
   readonly "listInvites": (
     options: typeof ListInvitesParams.Encoded
   ) => Effect.Effect<typeof InviteListResponse.Type, HttpClientError.HttpClientError | ParseError>
@@ -3994,6 +5449,18 @@ export interface Client {
   readonly "archiveProject": (
     projectId: string
   ) => Effect.Effect<typeof Project.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "listProjectRateLimits": (
+    projectId: string,
+    options: typeof ListProjectRateLimitsParams.Encoded
+  ) => Effect.Effect<typeof ProjectRateLimitListResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "updateProjectRateLimits": (
+    projectId: string,
+    rateLimitId: string,
+    options: typeof ProjectRateLimitUpdateRequest.Encoded
+  ) => Effect.Effect<
+    typeof ProjectRateLimit.Type,
+    HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
+  >
   readonly "listProjectServiceAccounts": (
     projectId: string,
     options: typeof ListProjectServiceAccountsParams.Encoded
@@ -4043,6 +5510,30 @@ export interface Client {
     typeof ProjectUserDeleteResponse.Type,
     HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
   >
+  readonly "usageAudioSpeeches": (
+    options: typeof UsageAudioSpeechesParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageAudioTranscriptions": (
+    options: typeof UsageAudioTranscriptionsParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageCodeInterpreterSessions": (
+    options: typeof UsageCodeInterpreterSessionsParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageCompletions": (
+    options: typeof UsageCompletionsParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageEmbeddings": (
+    options: typeof UsageEmbeddingsParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageImages": (
+    options: typeof UsageImagesParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageModerations": (
+    options: typeof UsageModerationsParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "usageVectorStores": (
+    options: typeof UsageVectorStoresParams.Encoded
+  ) => Effect.Effect<typeof UsageResponse.Type, HttpClientError.HttpClientError | ParseError>
   readonly "listUsers": (
     options: typeof ListUsersParams.Encoded
   ) => Effect.Effect<typeof UserListResponse.Type, HttpClientError.HttpClientError | ParseError>
@@ -4056,6 +5547,9 @@ export interface Client {
   readonly "deleteUser": (
     userId: string
   ) => Effect.Effect<typeof UserDeleteResponse.Type, HttpClientError.HttpClientError | ParseError>
+  readonly "createRealtimeSession": (
+    options: typeof RealtimeSessionCreateRequest.Encoded
+  ) => Effect.Effect<typeof RealtimeSessionCreateResponse.Type, HttpClientError.HttpClientError | ParseError>
   readonly "createThread": (
     options: typeof CreateThreadRequest.Encoded
   ) => Effect.Effect<typeof ThreadObject.Type, HttpClientError.HttpClientError | ParseError>