mistralai 1.9.10__py3-none-any.whl → 1.10.0__py3-none-any.whl

mistralai/models/embeddingrequest.py

@@ -13,33 +13,33 @@ from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 EmbeddingRequestInputsTypedDict = TypeAliasType(
     "EmbeddingRequestInputsTypedDict", Union[str, List[str]]
 )
-r"""Text to embed."""
+r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
 
 
 EmbeddingRequestInputs = TypeAliasType("EmbeddingRequestInputs", Union[str, List[str]])
-r"""Text to embed."""
+r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
 
 
 class EmbeddingRequestTypedDict(TypedDict):
     model: str
-    r"""ID of the model to use."""
+    r"""The ID of the model to be used for embedding."""
     inputs: EmbeddingRequestInputsTypedDict
-    r"""Text to embed."""
+    r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
     output_dimension: NotRequired[Nullable[int]]
-    r"""The dimension of the output embeddings."""
+    r"""The dimension of the output embeddings when feature available. If not provided, a default output dimension will be used."""
     output_dtype: NotRequired[EmbeddingDtype]
     encoding_format: NotRequired[EncodingFormat]
 
 
 class EmbeddingRequest(BaseModel):
     model: str
-    r"""ID of the model to use."""
+    r"""The ID of the model to be used for embedding."""
 
     inputs: Annotated[EmbeddingRequestInputs, pydantic.Field(alias="input")]
-    r"""Text to embed."""
+    r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
 
     output_dimension: OptionalNullable[int] = UNSET
-    r"""The dimension of the output embeddings."""
+    r"""The dimension of the output embeddings when feature available. If not provided, a default output dimension will be used."""
 
     output_dtype: Optional[EmbeddingDtype] = None
 

mistralai/models/files_api_routes_list_filesop.py

@@ -15,6 +15,7 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 class FilesAPIRoutesListFilesRequestTypedDict(TypedDict):
     page: NotRequired[int]
     page_size: NotRequired[int]
+    include_total: NotRequired[bool]
     sample_type: NotRequired[Nullable[List[SampleType]]]
     source: NotRequired[Nullable[List[Source]]]
     search: NotRequired[Nullable[str]]
@@ -32,6 +33,11 @@ class FilesAPIRoutesListFilesRequest(BaseModel):
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = 100
 
+    include_total: Annotated[
+        Optional[bool],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = True
+
     sample_type: Annotated[
         OptionalNullable[
             List[Annotated[SampleType, PlainValidator(validate_open_enum(False))]]
@@ -63,6 +69,7 @@ class FilesAPIRoutesListFilesRequest(BaseModel):
         optional_fields = [
             "page",
             "page_size",
+            "include_total",
             "sample_type",
             "source",
             "search",

mistralai/models/fimcompletionrequest.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
@@ -21,10 +21,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 class FIMCompletionRequestTypedDict(TypedDict):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
     prompt: str
     r"""The text/code to complete."""
     temperature: NotRequired[Nullable[float]]
@@ -39,6 +36,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     suffix: NotRequired[Nullable[str]]
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
     min_tokens: NotRequired[Nullable[int]]
@@ -47,10 +45,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
 
 class FIMCompletionRequest(BaseModel):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
 
     prompt: str
     r"""The text/code to complete."""
@@ -73,6 +68,8 @@ class FIMCompletionRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     suffix: OptionalNullable[str] = UNSET
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
 
@@ -88,6 +85,7 @@ class FIMCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -95,6 +93,7 @@ class FIMCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]

mistralai/models/fimcompletionstreamrequest.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
@@ -21,10 +21,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 class FIMCompletionStreamRequestTypedDict(TypedDict):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
     prompt: str
     r"""The text/code to complete."""
     temperature: NotRequired[Nullable[float]]
@@ -38,6 +35,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     suffix: NotRequired[Nullable[str]]
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
     min_tokens: NotRequired[Nullable[int]]
@@ -46,10 +44,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
 
 class FIMCompletionStreamRequest(BaseModel):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
 
     prompt: str
     r"""The text/code to complete."""
@@ -71,6 +66,8 @@ class FIMCompletionStreamRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     suffix: OptionalNullable[str] = UNSET
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
 
@@ -86,6 +83,7 @@ class FIMCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -93,6 +91,7 @@ class FIMCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]

mistralai/models/httpvalidationerror.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 from .validationerror import ValidationError
-from mistralai import utils
+import httpx
+from mistralai.models import MistralError
 from mistralai.types import BaseModel
 from typing import List, Optional
 
@@ -11,11 +12,15 @@ class HTTPValidationErrorData(BaseModel):
     detail: Optional[List[ValidationError]] = None
 
 
-class HTTPValidationError(Exception):
+class HTTPValidationError(MistralError):
     data: HTTPValidationErrorData
 
-    def __init__(self, data: HTTPValidationErrorData):
+    def __init__(
+        self,
+        data: HTTPValidationErrorData,
+        raw_response: httpx.Response,
+        body: Optional[str] = None,
+    ):
+        message = body or raw_response.text
+        super().__init__(message, raw_response, body)
         self.data = data
-
-    def __str__(self) -> str:
-        return utils.marshal_json(self.data, HTTPValidationErrorData)

mistralai/models/libraries_documents_list_v1op.py

@@ -13,6 +13,7 @@ class LibrariesDocumentsListV1RequestTypedDict(TypedDict):
     search: NotRequired[Nullable[str]]
     page_size: NotRequired[int]
     page: NotRequired[int]
+    filters_attributes: NotRequired[Nullable[str]]
     sort_by: NotRequired[str]
     sort_order: NotRequired[str]
 
@@ -37,6 +38,11 @@ class LibrariesDocumentsListV1Request(BaseModel):
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = 0
 
+    filters_attributes: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+
     sort_by: Annotated[
         Optional[str],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
@@ -49,8 +55,15 @@ class LibrariesDocumentsListV1Request(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["search", "page_size", "page", "sort_by", "sort_order"]
-        nullable_fields = ["search"]
+        optional_fields = [
+            "search",
+            "page_size",
+            "page",
+            "filters_attributes",
+            "sort_by",
+            "sort_order",
+        ]
+        nullable_fields = ["search", "filters_attributes"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/libraryout.py

@@ -12,18 +12,19 @@ class LibraryOutTypedDict(TypedDict):
     name: str
     created_at: datetime
     updated_at: datetime
-    owner_id: str
+    owner_id: Nullable[str]
     owner_type: str
     total_size: int
     nb_documents: int
     chunk_size: Nullable[int]
     emoji: NotRequired[Nullable[str]]
     description: NotRequired[Nullable[str]]
-    generated_name: NotRequired[Nullable[str]]
     generated_description: NotRequired[Nullable[str]]
     explicit_user_members_count: NotRequired[Nullable[int]]
     explicit_workspace_members_count: NotRequired[Nullable[int]]
     org_sharing_role: NotRequired[Nullable[str]]
+    generated_name: NotRequired[Nullable[str]]
+    r"""Generated Name"""
 
 
 class LibraryOut(BaseModel):
@@ -35,7 +36,7 @@ class LibraryOut(BaseModel):
 
     updated_at: datetime
 
-    owner_id: str
+    owner_id: Nullable[str]
 
     owner_type: str
 
@@ -49,8 +50,6 @@ class LibraryOut(BaseModel):
 
     description: OptionalNullable[str] = UNSET
 
-    generated_name: OptionalNullable[str] = UNSET
-
     generated_description: OptionalNullable[str] = UNSET
 
     explicit_user_members_count: OptionalNullable[int] = UNSET
@@ -59,26 +58,30 @@ class LibraryOut(BaseModel):
 
     org_sharing_role: OptionalNullable[str] = UNSET
 
+    generated_name: OptionalNullable[str] = UNSET
+    r"""Generated Name"""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
             "emoji",
             "description",
-            "generated_name",
             "generated_description",
             "explicit_user_members_count",
             "explicit_workspace_members_count",
             "org_sharing_role",
+            "generated_name",
         ]
         nullable_fields = [
+            "owner_id",
             "chunk_size",
             "emoji",
             "description",
-            "generated_name",
             "generated_description",
             "explicit_user_members_count",
             "explicit_workspace_members_count",
             "org_sharing_role",
+            "generated_name",
         ]
         null_default_fields = []
 

mistralai/models/listfilesout.py

@@ -2,15 +2,16 @@
 
 from __future__ import annotations
 from .fileschema import FileSchema, FileSchemaTypedDict
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
 from typing import List
-from typing_extensions import TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class ListFilesOutTypedDict(TypedDict):
     data: List[FileSchemaTypedDict]
     object: str
-    total: int
+    total: NotRequired[Nullable[int]]
 
 
 class ListFilesOut(BaseModel):
@@ -18,4 +19,34 @@ class ListFilesOut(BaseModel):
 
     object: str
 
-    total: int
+    total: OptionalNullable[int] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["total"]
+        nullable_fields = ["total"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mistralai/models/mistralerror.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from typing import Optional
+
+
+class MistralError(Exception):
+    """The base class for all HTTP error responses."""
+
+    message: str
+    status_code: int
+    body: str
+    headers: httpx.Headers
+    raw_response: httpx.Response
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        self.message = message
+        self.status_code = raw_response.status_code
+        self.body = body if body is not None else raw_response.text
+        self.headers = raw_response.headers
+        self.raw_response = raw_response
+
+    def __str__(self):
+        return self.message

mistralai/models/modelcapabilities.py

@@ -8,22 +8,31 @@ from typing_extensions import NotRequired, TypedDict
 
 class ModelCapabilitiesTypedDict(TypedDict):
     completion_chat: NotRequired[bool]
-    completion_fim: NotRequired[bool]
     function_calling: NotRequired[bool]
+    completion_fim: NotRequired[bool]
     fine_tuning: NotRequired[bool]
     vision: NotRequired[bool]
+    ocr: NotRequired[bool]
     classification: NotRequired[bool]
+    moderation: NotRequired[bool]
+    audio: NotRequired[bool]
 
 
 class ModelCapabilities(BaseModel):
-    completion_chat: Optional[bool] = True
+    completion_chat: Optional[bool] = False
 
-    completion_fim: Optional[bool] = False
+    function_calling: Optional[bool] = False
 
-    function_calling: Optional[bool] = True
+    completion_fim: Optional[bool] = False
 
     fine_tuning: Optional[bool] = False
 
     vision: Optional[bool] = False
 
+    ocr: Optional[bool] = False
+
     classification: Optional[bool] = False
+
+    moderation: Optional[bool] = False
+
+    audio: Optional[bool] = False

mistralai/models/modelconversation.py

@@ -12,7 +12,7 @@ from datetime import datetime
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import get_discriminator
 from pydantic import Discriminator, Tag, model_serializer
-from typing import List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -60,6 +60,8 @@ class ModelConversationTypedDict(TypedDict):
     r"""Name given to the conversation."""
     description: NotRequired[Nullable[str]]
     r"""Description of the what the conversation is about."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
+    r"""Custom metadata for the conversation."""
     object: NotRequired[ModelConversationObject]
 
 
@@ -87,6 +89,9 @@ class ModelConversation(BaseModel):
     description: OptionalNullable[str] = UNSET
     r"""Description of the what the conversation is about."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+    r"""Custom metadata for the conversation."""
+
     object: Optional[ModelConversationObject] = "conversation"
 
     @model_serializer(mode="wrap")
@@ -97,9 +102,10 @@ class ModelConversation(BaseModel):
             "completion_args",
             "name",
             "description",
+            "metadata",
             "object",
         ]
-        nullable_fields = ["instructions", "name", "description"]
+        nullable_fields = ["instructions", "name", "description", "metadata"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/no_response_error.py

@@ -0,0 +1,13 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+class NoResponseError(Exception):
+    """Error raised when no HTTP response is received from the server."""
+
+    message: str
+
+    def __init__(self, message: str = "No response received"):
+        self.message = message
+        super().__init__(message)
+
+    def __str__(self):
+        return self.message

mistralai/models/ocrpageobject.py

@@ -3,10 +3,11 @@
 from __future__ import annotations
 from .ocrimageobject import OCRImageObject, OCRImageObjectTypedDict
 from .ocrpagedimensions import OCRPageDimensions, OCRPageDimensionsTypedDict
-from mistralai.types import BaseModel, Nullable, UNSET_SENTINEL
+from .ocrtableobject import OCRTableObject, OCRTableObjectTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import List
-from typing_extensions import TypedDict
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
 
 
 class OCRPageObjectTypedDict(TypedDict):
@@ -18,6 +19,14 @@ class OCRPageObjectTypedDict(TypedDict):
     r"""List of all extracted images in the page"""
     dimensions: Nullable[OCRPageDimensionsTypedDict]
     r"""The dimensions of the PDF Page's screenshot image"""
+    tables: NotRequired[List[OCRTableObjectTypedDict]]
+    r"""List of all extracted tables in the page"""
+    hyperlinks: NotRequired[List[str]]
+    r"""List of all hyperlinks in the page"""
+    header: NotRequired[Nullable[str]]
+    r"""Header of the page"""
+    footer: NotRequired[Nullable[str]]
+    r"""Footer of the page"""
 
 
 class OCRPageObject(BaseModel):
@@ -33,10 +42,22 @@ class OCRPageObject(BaseModel):
     dimensions: Nullable[OCRPageDimensions]
     r"""The dimensions of the PDF Page's screenshot image"""
 
+    tables: Optional[List[OCRTableObject]] = None
+    r"""List of all extracted tables in the page"""
+
+    hyperlinks: Optional[List[str]] = None
+    r"""List of all hyperlinks in the page"""
+
+    header: OptionalNullable[str] = UNSET
+    r"""Header of the page"""
+
+    footer: OptionalNullable[str] = UNSET
+    r"""Footer of the page"""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["dimensions"]
+        optional_fields = ["tables", "hyperlinks", "header", "footer"]
+        nullable_fields = ["header", "footer", "dimensions"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/ocrrequest.py

@@ -7,7 +7,7 @@ from .imageurlchunk import ImageURLChunk, ImageURLChunkTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
@@ -22,6 +22,9 @@ Document = TypeAliasType("Document", Union[FileChunk, ImageURLChunk, DocumentURL
 r"""Document to run OCR on"""
 
 
+TableFormat = Literal["markdown", "html"]
+
+
 class OCRRequestTypedDict(TypedDict):
     model: Nullable[str]
     document: DocumentTypedDict
@@ -39,6 +42,9 @@ class OCRRequestTypedDict(TypedDict):
     r"""Structured output class for extracting useful information from each extracted bounding box / image from document. Only json_schema is valid for this field"""
     document_annotation_format: NotRequired[Nullable[ResponseFormatTypedDict]]
     r"""Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field"""
+    table_format: NotRequired[Nullable[TableFormat]]
+    extract_header: NotRequired[bool]
+    extract_footer: NotRequired[bool]
 
 
 class OCRRequest(BaseModel):
@@ -67,6 +73,12 @@ class OCRRequest(BaseModel):
     document_annotation_format: OptionalNullable[ResponseFormat] = UNSET
     r"""Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field"""
 
+    table_format: OptionalNullable[TableFormat] = UNSET
+
+    extract_header: Optional[bool] = None
+
+    extract_footer: Optional[bool] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -77,6 +89,9 @@ class OCRRequest(BaseModel):
             "image_min_size",
             "bbox_annotation_format",
             "document_annotation_format",
+            "table_format",
+            "extract_header",
+            "extract_footer",
         ]
         nullable_fields = [
             "model",
@@ -86,6 +101,7 @@ class OCRRequest(BaseModel):
             "image_min_size",
             "bbox_annotation_format",
             "document_annotation_format",
+            "table_format",
         ]
         null_default_fields = []
 

mistralai/models/ocrtableobject.py

@@ -0,0 +1,31 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+import pydantic
+from typing import Literal
+from typing_extensions import Annotated, TypedDict
+
+
+Format = Literal["markdown", "html"]
+r"""Format of the table"""
+
+
+class OCRTableObjectTypedDict(TypedDict):
+    id: str
+    r"""Table ID for extracted table in a page"""
+    content: str
+    r"""Content of the table in the given format"""
+    format_: Format
+    r"""Format of the table"""
+
+
+class OCRTableObject(BaseModel):
+    id: str
+    r"""Table ID for extracted table in a page"""
+
+    content: str
+    r"""Content of the table in the given format"""
+
+    format_: Annotated[Format, pydantic.Field(alias="format")]
+    r"""Format of the table"""