# Shared Types

```python
from openai.types import ErrorObject, FunctionDefinition, FunctionParameters
```

# Completions

Types:

```python
from openai.types import Completion, CompletionChoice, CompletionUsage
```

Methods:

- client.completions.create(\*\*params) -> Completion

# Chat

Types:

```python
from openai.types import ChatModel
```

## Completions

Types:

```python
from openai.types.chat import (
    ChatCompletion,
    ChatCompletionAssistantMessageParam,
    ChatCompletionChunk,
    ChatCompletionContentPart,
    ChatCompletionContentPartImage,
    ChatCompletionContentPartText,
    ChatCompletionFunctionCallOption,
    ChatCompletionFunctionMessageParam,
    ChatCompletionMessage,
    ChatCompletionMessageParam,
    ChatCompletionMessageToolCall,
    ChatCompletionNamedToolChoice,
    ChatCompletionRole,
    ChatCompletionStreamOptions,
    ChatCompletionSystemMessageParam,
    ChatCompletionTokenLogprob,
    ChatCompletionTool,
    ChatCompletionToolChoiceOption,
    ChatCompletionToolMessageParam,
    ChatCompletionUserMessageParam,
)
```

Methods:

- client.chat.completions.create(\*\*params) -> ChatCompletion

# Embeddings

Types:

```python
from openai.types import CreateEmbeddingResponse, Embedding
```

Methods:

- client.embeddings.create(\*\*params) -> CreateEmbeddingResponse

# Files

Types:

```python
from openai.types import FileContent, FileDeleted, FileObject
```

Methods:

- client.files.create(\*\*params) -> FileObject
- client.files.retrieve(file_id) -> FileObject
- client.files.list(\*\*params) -> SyncPage[FileObject]
- client.files.delete(file_id) -> FileDeleted
- client.files.content(file_id) -> HttpxBinaryResponseContent
- client.files.retrieve_content(file_id) -> str
- client.files.wait_for_processing(\*args) -> FileObject

# Images

Types:

```python
from openai.types import Image, ImagesResponse
```

Methods:

- client.images.create_variation(\*\*params) -> ImagesResponse
- client.images.edit(\*\*params) -> ImagesResponse
- client.images.generate(\*\*params) -> ImagesResponse

# Audio

## Transcriptions

Types:

```python
from openai.types.audio import Transcription
```

Methods:

- client.audio.transcriptions.create(\*\*params) -> Transcription

## Translations

Types:

```python
from openai.types.audio import Translation
```

Methods:

- client.audio.translations.create(\*\*params) -> Translation

## Speech

Methods:

- client.audio.speech.create(\*\*params) -> HttpxBinaryResponseContent

# Moderations

Types:

```python
from openai.types import Moderation, ModerationCreateResponse
```

Methods:

- client.moderations.create(\*\*params) -> ModerationCreateResponse

# Models

Types:

```python
from openai.types import Model, ModelDeleted
```

Methods:

- client.models.retrieve(model) -> Model
- client.models.list() -> SyncPage[Model]
- client.models.delete(model) -> ModelDeleted

# FineTuning

## Jobs

Types:

```python
from openai.types.fine_tuning import (
    FineTuningJob,
    FineTuningJobEvent,
    FineTuningJobIntegration,
    FineTuningJobWandbIntegration,
    FineTuningJobWandbIntegrationObject,
)
```

Methods:

- client.fine_tuning.jobs.create(\*\*params) -> FineTuningJob
- client.fine_tuning.jobs.retrieve(fine_tuning_job_id) -> FineTuningJob
- client.fine_tuning.jobs.list(\*\*params) -> SyncCursorPage[FineTuningJob]
- client.fine_tuning.jobs.cancel(fine_tuning_job_id) -> FineTuningJob
- client.fine_tuning.jobs.list_events(fine_tuning_job_id, \*\*params) -> SyncCursorPage[FineTuningJobEvent]

### Checkpoints

Types:

```python
from openai.types.fine_tuning.jobs import FineTuningJobCheckpoint
```

Methods:

- client.fine_tuning.jobs.checkpoints.list(fine_tuning_job_id, \*\*params) -> SyncCursorPage[FineTuningJobCheckpoint]

# Beta

## VectorStores

Types:

```python
from openai.types.beta import VectorStore, VectorStoreDeleted
```

Methods:

- client.beta.vector_stores.create(\*\*params) -> VectorStore
- client.beta.vector_stores.retrieve(vector_store_id) -> VectorStore
- client.beta.vector_stores.update(vector_store_id, \*\*params) -> VectorStore
- client.beta.vector_stores.list(\*\*params) -> SyncCursorPage[VectorStore]
- client.beta.vector_stores.delete(vector_store_id) -> VectorStoreDeleted

### Files

Types:

```python
from openai.types.beta.vector_stores import VectorStoreFile, VectorStoreFileDeleted
```

Methods:

- client.beta.vector_stores.files.create(vector_store_id, \*\*params) -> VectorStoreFile
- client.beta.vector_stores.files.retrieve(file_id, \*, vector_store_id) -> VectorStoreFile
- client.beta.vector_stores.files.list(vector_store_id, \*\*params) -> SyncCursorPage[VectorStoreFile]
- client.beta.vector_stores.files.delete(file_id, \*, vector_store_id) -> VectorStoreFileDeleted
- client.beta.vector_stores.files.create_and_poll(\*args) -> VectorStoreFile
- client.beta.vector_stores.files.poll(\*args) -> VectorStoreFile
- client.beta.vector_stores.files.upload(\*args) -> VectorStoreFile
- client.beta.vector_stores.files.upload_and_poll(\*args) -> VectorStoreFile

### FileBatches

Types:

```python
from openai.types.beta.vector_stores import VectorStoreFileBatch
```

Methods:

- client.beta.vector_stores.file_batches.create(vector_store_id, \*\*params) -> VectorStoreFileBatch
- client.beta.vector_stores.file_batches.retrieve(batch_id, \*, vector_store_id) -> VectorStoreFileBatch
- client.beta.vector_stores.file_batches.cancel(batch_id, \*, vector_store_id) -> VectorStoreFileBatch
- client.beta.vector_stores.file_batches.list_files(batch_id, \*, vector_store_id, \*\*params) -> SyncCursorPage[VectorStoreFile]
- client.beta.vector_stores.file_batches.create_and_poll(\*args) -> VectorStoreFileBatch
- client.beta.vector_stores.file_batches.poll(\*args) -> VectorStoreFileBatch
- client.beta.vector_stores.file_batches.upload_and_poll(\*args) -> VectorStoreFileBatch

## Assistants

Types:

```python
from openai.types.beta import (
    Assistant,
    AssistantDeleted,
    AssistantStreamEvent,
    AssistantTool,
    CodeInterpreterTool,
    FileSearchTool,
    FunctionTool,
    MessageStreamEvent,
    RunStepStreamEvent,
    RunStreamEvent,
    ThreadStreamEvent,
)
```

Methods:

- client.beta.assistants.create(\*\*params) -> Assistant
- client.beta.assistants.retrieve(assistant_id) -> Assistant
- client.beta.assistants.update(assistant_id, \*\*params) -> Assistant
- client.beta.assistants.list(\*\*params) -> SyncCursorPage[Assistant]
- client.beta.assistants.delete(assistant_id) -> AssistantDeleted

## Threads

Types:

```python
from openai.types.beta import (
    AssistantResponseFormat,
    AssistantResponseFormatOption,
    AssistantToolChoice,
    AssistantToolChoiceFunction,
    AssistantToolChoiceOption,
    Thread,
    ThreadDeleted,
)
```

Methods:

- client.beta.threads.create(\*\*params) -> Thread
- client.beta.threads.retrieve(thread_id) -> Thread
- client.beta.threads.update(thread_id, \*\*params) -> Thread
- client.beta.threads.delete(thread_id) -> ThreadDeleted
- client.beta.threads.create_and_run(\*\*params) -> Run
- client.beta.threads.create_and_run_poll(\*args) -> Run
- client.beta.threads.create_and_run_stream(\*args) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]

### Runs

Types:

```python
from openai.types.beta.threads import RequiredActionFunctionToolCall, Run, RunStatus
```

Methods:

- client.beta.threads.runs.create(thread_id, \*\*params) -> Run
- client.beta.threads.runs.retrieve(run_id, \*, thread_id) -> Run
- client.beta.threads.runs.update(run_id, \*, thread_id, \*\*params) -> Run
- client.beta.threads.runs.list(thread_id, \*\*params) -> SyncCursorPage[Run]
- client.beta.threads.runs.cancel(run_id, \*, thread_id) -> Run
- client.beta.threads.runs.submit_tool_outputs(run_id, \*, thread_id, \*\*params) -> Run
- client.beta.threads.runs.create_and_poll(\*args) -> Run
- client.beta.threads.runs.create_and_stream(\*args) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
- client.beta.threads.runs.poll(\*args) -> Run
- client.beta.threads.runs.stream(\*args) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
- client.beta.threads.runs.submit_tool_outputs_and_poll(\*args) -> Run
- client.beta.threads.runs.submit_tool_outputs_stream(\*args) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]

#### Steps

Types:

```python
from openai.types.beta.threads.runs import (
    CodeInterpreterLogs,
    CodeInterpreterOutputImage,
    CodeInterpreterToolCall,
    CodeInterpreterToolCallDelta,
    FileSearchToolCall,
    FileSearchToolCallDelta,
    FunctionToolCall,
    FunctionToolCallDelta,
    MessageCreationStepDetails,
    RunStep,
    RunStepDelta,
    RunStepDeltaEvent,
    RunStepDeltaMessageDelta,
    ToolCall,
    ToolCallDelta,
    ToolCallDeltaObject,
    ToolCallsStepDetails,
)
```

Methods:

- client.beta.threads.runs.steps.retrieve(step_id, \*, thread_id, run_id) -> RunStep
- client.beta.threads.runs.steps.list(run_id, \*, thread_id, \*\*params) -> SyncCursorPage[RunStep]

### Messages

Types:

```python
from openai.types.beta.threads import (
    Annotation,
    AnnotationDelta,
    FileCitationAnnotation,
    FileCitationDeltaAnnotation,
    FilePathAnnotation,
    FilePathDeltaAnnotation,
    ImageFile,
    ImageFileContentBlock,
    ImageFileDelta,
    ImageFileDeltaBlock,
    ImageURL,
    ImageURLContentBlock,
    ImageURLDelta,
    ImageURLDeltaBlock,
    Message,
    MessageContent,
    MessageContentDelta,
    MessageContentPartParam,
    MessageDeleted,
    MessageDelta,
    MessageDeltaEvent,
    Text,
    TextContentBlock,
    TextContentBlockParam,
    TextDelta,
    TextDeltaBlock,
)
```

Methods:

- client.beta.threads.messages.create(thread_id, \*\*params) -> Message
- client.beta.threads.messages.retrieve(message_id, \*, thread_id) -> Message
- client.beta.threads.messages.update(message_id, \*, thread_id, \*\*params) -> Message
- client.beta.threads.messages.list(thread_id, \*\*params) -> SyncCursorPage[Message]
- client.beta.threads.messages.delete(message_id, \*, thread_id) -> MessageDeleted

# Batches

Types:

```python
from openai.types import Batch, BatchError, BatchRequestCounts
```

Methods:

- client.batches.create(\*\*params) -> Batch
- client.batches.retrieve(batch_id) -> Batch
- client.batches.list(\*\*params) -> SyncCursorPage[Batch]
- client.batches.cancel(batch_id) -> Batch

# Uploads

Types:

```python
from openai.types import Upload
```

Methods:

- client.uploads.create(\*\*params) -> Upload
- client.uploads.cancel(upload_id) -> Upload
- client.uploads.complete(upload_id, \*\*params) -> Upload

## Parts

Types:

```python
from openai.types.uploads import UploadPart
```

Methods:

- client.uploads.parts.create(upload_id, \*\*params) -> UploadPart