supermemory 3.0.0a29__py3-none-any.whl → 3.1.0__py3-none-any.whl

supermemory/types/memory_list_params.py

@@ -2,24 +2,38 @@
 
 from __future__ import annotations
 
-from typing import List, Union
-from typing_extensions import Literal, Annotated, TypedDict
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
-__all__ = ["MemoryListParams"]
+__all__ = [
+    "MemoryListParams",
+    "Filters",
+    "FiltersOr",
+    "FiltersOrOr",
+    "FiltersOrOrUnionMember0",
+    "FiltersOrOrOr",
+    "FiltersOrOrAnd",
+    "FiltersAnd",
+    "FiltersAndAnd",
+    "FiltersAndAndUnionMember0",
+    "FiltersAndAndOr",
+    "FiltersAndAndAnd",
+]
 
 
 class MemoryListParams(TypedDict, total=False):
-    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
-    """Optional tags this memory should be containerized by.
+    container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")]
+    """Optional tags this document should be containerized by.
 
     This can be an ID for your user, a project ID, or any other identifier you wish
-    to use to group memories.
+    to use to group documents.
     """
 
-    filters: str
-    """Optional filters to apply to the search"""
+    filters: Filters
+    """Optional filters to apply to the search. Can be a JSON string or Query object."""
 
     include_content: Annotated[bool, PropertyInfo(alias="includeContent")]
     """Whether to include the content field in the response.
@@ -38,3 +52,60 @@ class MemoryListParams(TypedDict, total=False):
 
     sort: Literal["createdAt", "updatedAt"]
     """Field to sort by"""
+
+
+class FiltersOrOrUnionMember0(TypedDict, total=False):
+    key: Required[str]
+
+    value: Required[str]
+
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
+
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersOrOrOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersOrOrAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd]
+
+
+class FiltersOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndUnionMember0(TypedDict, total=False):
+    key: Required[str]
+
+    value: Required[str]
+
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
+
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersAndAndOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd]
+
+
+class FiltersAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]]
+
+
+Filters: TypeAlias = Union[FiltersOr, FiltersAnd]

supermemory/types/memory_list_response.py

@@ -13,40 +13,41 @@ __all__ = ["MemoryListResponse", "Memory", "Pagination"]
 
 class Memory(BaseModel):
     id: str
-    """Unique identifier of the memory."""
+    """Unique identifier of the document."""
 
     connection_id: Optional[str] = FieldInfo(alias="connectionId", default=None)
-    """Optional ID of connection the memory was created from.
+    """Optional ID of connection the document was created from.
 
-    This is useful for identifying the source of the memory.
+    This is useful for identifying the source of the document.
     """
 
     created_at: datetime = FieldInfo(alias="createdAt")
     """Creation timestamp"""
 
     custom_id: Optional[str] = FieldInfo(alias="customId", default=None)
-    """Optional custom ID of the memory.
+    """Optional custom ID of the document.
 
-    This could be an ID from your database that will uniquely identify this memory.
+    This could be an ID from your database that will uniquely identify this
+    document.
     """
 
     metadata: Union[str, float, bool, Dict[str, object], List[object], None] = None
-    """Optional metadata for the memory.
+    """Optional metadata for the document.
 
-    This is used to store additional information about the memory. You can use this
-    to store any additional information you need about the memory. Metadata can be
-    filtered through. Keys must be strings and are case sensitive. Values can be
-    strings, numbers, or booleans. You cannot nest objects.
+    This is used to store additional information about the document. You can use
+    this to store any additional information you need about the document. Metadata
+    can be filtered through. Keys must be strings and are case sensitive. Values can
+    be strings, numbers, or booleans. You cannot nest objects.
     """
 
     status: Literal["unknown", "queued", "extracting", "chunking", "embedding", "indexing", "done", "failed"]
-    """Status of the memory"""
+    """Status of the document"""
 
     summary: Optional[str] = None
-    """Summary of the memory content"""
+    """Summary of the document content"""
 
     title: Optional[str] = None
-    """Title of the memory"""
+    """Title of the document"""
 
     type: Literal[
         "text",
@@ -61,20 +62,20 @@ class Memory(BaseModel):
         "webpage",
         "onedrive",
     ]
-    """Type of the memory"""
+    """Type of the document"""
 
     updated_at: datetime = FieldInfo(alias="updatedAt")
     """Last update timestamp"""
 
     container_tags: Optional[List[str]] = FieldInfo(alias="containerTags", default=None)
-    """Optional tags this memory should be containerized by.
+    """Optional tags this document should be containerized by.
 
     This can be an ID for your user, a project ID, or any other identifier you wish
-    to use to group memories.
+    to use to group documents.
     """
 
     content: Optional[str] = None
-    """Content of the memory (only included when includeContent=true)"""
+    """Content of the document (only included when includeContent=true)"""
 
 
 class Pagination(BaseModel):

supermemory/types/memory_update_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union
+from typing import Dict, Union
 from typing_extensions import Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["MemoryUpdateParams"]
@@ -12,21 +13,21 @@ __all__ = ["MemoryUpdateParams"]
 
 class MemoryUpdateParams(TypedDict, total=False):
     container_tag: Annotated[str, PropertyInfo(alias="containerTag")]
-    """Optional tag this memory should be containerized by.
+    """Optional tag this document should be containerized by.
 
     This can be an ID for your user, a project ID, or any other identifier you wish
-    to use to group memories.
+    to use to group documents.
     """
 
-    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")]
     """
-    (DEPRECATED: Use containerTag instead) Optional tags this memory should be
+    (DEPRECATED: Use containerTag instead) Optional tags this document should be
     containerized by. This can be an ID for your user, a project ID, or any other
-    identifier you wish to use to group memories.
+    identifier you wish to use to group documents.
     """
 
     content: str
-    """The content to extract and process into a memory.
+    """The content to extract and process into a document.
 
     This can be a URL to a website, a PDF, an image, or a video.
 
@@ -38,16 +39,31 @@ class MemoryUpdateParams(TypedDict, total=False):
     """
 
     custom_id: Annotated[str, PropertyInfo(alias="customId")]
-    """Optional custom ID of the memory.
+    """Optional custom ID of the document.
 
-    This could be an ID from your database that will uniquely identify this memory.
+    This could be an ID from your database that will uniquely identify this
+    document.
     """
 
-    metadata: Dict[str, Union[str, float, bool]]
-    """Optional metadata for the memory.
+    file_type: Annotated[str, PropertyInfo(alias="fileType")]
+    """Optional file type override to force specific processing behavior.
 
-    This is used to store additional information about the memory. You can use this
-    to store any additional information you need about the memory. Metadata can be
-    filtered through. Keys must be strings and are case sensitive. Values can be
-    strings, numbers, or booleans. You cannot nest objects.
+    Valid values: text, pdf, tweet, google_doc, google_slide, google_sheet, image,
+    video, notion_doc, webpage, onedrive
+    """
+
+    metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]]
+    """Optional metadata for the document.
+
+    This is used to store additional information about the document. You can use
+    this to store any additional information you need about the document. Metadata
+    can be filtered through. Keys must be strings and are case sensitive. Values can
+    be strings, numbers, or booleans. You cannot nest objects.
+    """
+
+    mime_type: Annotated[str, PropertyInfo(alias="mimeType")]
+    """Required when fileType is 'image' or 'video'.
+
+    Specifies the exact MIME type to use (e.g., 'image/png', 'image/jpeg',
+    'video/mp4', 'video/webm')
     """

supermemory/types/memory_upload_file_params.py

@@ -12,5 +12,25 @@ __all__ = ["MemoryUploadFileParams"]
 
 class MemoryUploadFileParams(TypedDict, total=False):
     file: Required[FileTypes]
+    """File to upload and process"""
 
     container_tags: Annotated[str, PropertyInfo(alias="containerTags")]
+    """Optional JSON string of container tags array.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to group documents.
+    """
+
+    file_type: Annotated[str, PropertyInfo(alias="fileType")]
+    """Optional file type override to force specific processing behavior.
+
+    Valid values: text, pdf, tweet, google_doc, google_slide, google_sheet, image,
+    video, notion_doc, webpage, onedrive
+    """
+
+    mime_type: Annotated[str, PropertyInfo(alias="mimeType")]
+    """Required when fileType is 'image' or 'video'.
+
+    Specifies the exact MIME type to use (e.g., 'image/png', 'image/jpeg',
+    'video/mp4', 'video/webm')
+    """

supermemory/types/search_documents_params.py

@@ -2,12 +2,26 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Iterable
+from typing import List, Union, Iterable
 from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
-__all__ = ["SearchDocumentsParams", "Filters", "FiltersUnionMember0"]
+__all__ = [
+    "SearchDocumentsParams",
+    "Filters",
+    "FiltersOr",
+    "FiltersOrOr",
+    "FiltersOrOrUnionMember0",
+    "FiltersOrOrOr",
+    "FiltersOrOrAnd",
+    "FiltersAnd",
+    "FiltersAndAnd",
+    "FiltersAndAndUnionMember0",
+    "FiltersAndAndOr",
+    "FiltersAndAndAnd",
+]
 
 
 class SearchDocumentsParams(TypedDict, total=False):
@@ -26,11 +40,11 @@ class SearchDocumentsParams(TypedDict, total=False):
     (returns lesser chunks, accurate results)
     """
 
-    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")]
     """Optional tags this search should be containerized by.
 
     This can be an ID for your user, a project ID, or any other identifier you wish
-    to use to filter memories.
+    to use to filter documents.
     """
 
     doc_id: Annotated[str, PropertyInfo(alias="docId")]
@@ -47,7 +61,7 @@ class SearchDocumentsParams(TypedDict, total=False):
     """
 
     filters: Filters
-    """Optional filters to apply to the search"""
+    """Optional filters to apply to the search. Can be a JSON string or Query object."""
 
     include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")]
     """If true, include full document in the response.
@@ -84,10 +98,58 @@ class SearchDocumentsParams(TypedDict, total=False):
     """
 
 
-class FiltersUnionMember0(TypedDict, total=False):
-    and_: Annotated[Iterable[object], PropertyInfo(alias="AND")]
+class FiltersOrOrUnionMember0(TypedDict, total=False):
+    key: Required[str]
 
-    or_: Annotated[Iterable[object], PropertyInfo(alias="OR")]
+    value: Required[str]
 
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
 
-Filters: TypeAlias = Union[FiltersUnionMember0, Dict[str, object]]
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersOrOrOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersOrOrAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd]
+
+
+class FiltersOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndUnionMember0(TypedDict, total=False):
+    key: Required[str]
+
+    value: Required[str]
+
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
+
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersAndAndOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd]
+
+
+class FiltersAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]]
+
+
+Filters: TypeAlias = Union[FiltersOr, FiltersAnd]

supermemory/types/search_execute_params.py

@@ -2,12 +2,26 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Iterable
+from typing import List, Union, Iterable
 from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
-__all__ = ["SearchExecuteParams", "Filters", "FiltersUnionMember0"]
+__all__ = [
+    "SearchExecuteParams",
+    "Filters",
+    "FiltersOr",
+    "FiltersOrOr",
+    "FiltersOrOrUnionMember0",
+    "FiltersOrOrOr",
+    "FiltersOrOrAnd",
+    "FiltersAnd",
+    "FiltersAndAnd",
+    "FiltersAndAndUnionMember0",
+    "FiltersAndAndOr",
+    "FiltersAndAndAnd",
+]
 
 
 class SearchExecuteParams(TypedDict, total=False):
@@ -26,11 +40,11 @@ class SearchExecuteParams(TypedDict, total=False):
     (returns lesser chunks, accurate results)
     """
 
-    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")]
     """Optional tags this search should be containerized by.
 
     This can be an ID for your user, a project ID, or any other identifier you wish
-    to use to filter memories.
+    to use to filter documents.
     """
 
     doc_id: Annotated[str, PropertyInfo(alias="docId")]
@@ -47,7 +61,7 @@ class SearchExecuteParams(TypedDict, total=False):
     """
 
     filters: Filters
-    """Optional filters to apply to the search"""
+    """Optional filters to apply to the search. Can be a JSON string or Query object."""
 
     include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")]
     """If true, include full document in the response.
@@ -84,10 +98,58 @@ class SearchExecuteParams(TypedDict, total=False):
     """
 
 
-class FiltersUnionMember0(TypedDict, total=False):
-    and_: Annotated[Iterable[object], PropertyInfo(alias="AND")]
+class FiltersOrOrUnionMember0(TypedDict, total=False):
+    key: Required[str]
 
-    or_: Annotated[Iterable[object], PropertyInfo(alias="OR")]
+    value: Required[str]
 
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
 
-Filters: TypeAlias = Union[FiltersUnionMember0, Dict[str, object]]
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersOrOrOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersOrOrAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd]
+
+
+class FiltersOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndUnionMember0(TypedDict, total=False):
+    key: Required[str]
+
+    value: Required[str]
+
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
+
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersAndAndOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd]
+
+
+class FiltersAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]]
+
+
+Filters: TypeAlias = Union[FiltersOr, FiltersAnd]

supermemory/types/search_memories_params.py

@@ -2,12 +2,26 @@
 
 from __future__ import annotations
 
-from typing import Dict, Union, Iterable
-from typing_extensions import Required, Annotated, TypeAlias, TypedDict
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
 
 from .._utils import PropertyInfo
 
-__all__ = ["SearchMemoriesParams", "Filters", "FiltersUnionMember0", "Include"]
+__all__ = [
+    "SearchMemoriesParams",
+    "Filters",
+    "FiltersOr",
+    "FiltersOrOr",
+    "FiltersOrOrUnionMember0",
+    "FiltersOrOrOr",
+    "FiltersOrOrAnd",
+    "FiltersAnd",
+    "FiltersAndAnd",
+    "FiltersAndAndUnionMember0",
+    "FiltersAndAndOr",
+    "FiltersAndAndAnd",
+    "Include",
+]
 
 
 class SearchMemoriesParams(TypedDict, total=False):
@@ -22,7 +36,7 @@ class SearchMemoriesParams(TypedDict, total=False):
     """
 
     filters: Filters
-    """Optional filters to apply to the search"""
+    """Optional filters to apply to the search. Can be a JSON string or Query object."""
 
     include: Include
 
@@ -49,18 +63,73 @@ class SearchMemoriesParams(TypedDict, total=False):
     """
 
 
-class FiltersUnionMember0(TypedDict, total=False):
-    and_: Annotated[Iterable[object], PropertyInfo(alias="AND")]
+class FiltersOrOrUnionMember0(TypedDict, total=False):
+    key: Required[str]
 
-    or_: Annotated[Iterable[object], PropertyInfo(alias="OR")]
+    value: Required[str]
 
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
 
-Filters: TypeAlias = Union[FiltersUnionMember0, Dict[str, object]]
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersOrOrOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersOrOrAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd]
+
+
+class FiltersOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndUnionMember0(TypedDict, total=False):
+    key: Required[str]
+
+    value: Required[str]
+
+    filter_type: Annotated[Literal["metadata", "numeric", "array_contains"], PropertyInfo(alias="filterType")]
+
+    negate: Union[bool, Literal["true", "false"]]
+
+    numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
+
+
+class FiltersAndAndOr(TypedDict, total=False):
+    or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
+
+
+class FiltersAndAndAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
+
+
+FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd]
+
+
+class FiltersAnd(TypedDict, total=False):
+    and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]]
+
+
+Filters: TypeAlias = Union[FiltersOr, FiltersAnd]
 
 
 class Include(TypedDict, total=False):
     documents: bool
 
+    forgotten_memories: Annotated[bool, PropertyInfo(alias="forgottenMemories")]
+    """If true, include forgotten memories in search results.
+
+    Forgotten memories are memories that have been explicitly forgotten or have
+    passed their expiration date.
+    """
+
     related_memories: Annotated[bool, PropertyInfo(alias="relatedMemories")]
 
     summaries: bool

supermemory/types/search_memories_response.py

@@ -71,17 +71,20 @@ class ResultDocument(BaseModel):
     created_at: datetime = FieldInfo(alias="createdAt")
     """Document creation date"""
 
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Document last update date"""
+
     metadata: Optional[Dict[str, object]] = None
-    """Document metadata"""
+    """Document metadata (only included when documents=true)"""
 
-    title: str
-    """Document title"""
+    summary: Optional[str] = None
+    """Document summary (only included when summaries=true)"""
 
-    type: str
-    """Document type"""
+    title: Optional[str] = None
+    """Document title (only included when documents=true)"""
 
-    updated_at: datetime = FieldInfo(alias="updatedAt")
-    """Document last update date"""
+    type: Optional[str] = None
+    """Document type (only included when documents=true)"""
 
 
 class Result(BaseModel):