finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/screengroup.py

@@ -0,0 +1,75 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 7946a4a7b84e
+
+from __future__ import annotations
+from .screenclause import ScreenClause, ScreenClauseTypedDict
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import field_serializer, model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ScreenGroupOperator(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How the clauses inside this group are combined:
+    - `AND` — every clause in the group must match (logical AND).
+    - `OR` — at least one clause in the group must match (logical OR).
+    - `NOT` — negate the clause inside the group (logical NOT).
+    """
+
+    AND = "AND"
+    OR = "OR"
+    NOT = "NOT"
+
+
+class ScreenGroupTypedDict(TypedDict):
+    r"""Nested group of clauses with its own operator (AND, OR, NOT)."""
+
+    clauses: NotRequired[List[ScreenClauseTypedDict]]
+    r"""Clauses combined by this group's operator."""
+    operator: NotRequired[ScreenGroupOperator]
+    r"""How the clauses inside this group are combined:
+    - `AND` — every clause in the group must match (logical AND).
+    - `OR` — at least one clause in the group must match (logical OR).
+    - `NOT` — negate the clause inside the group (logical NOT).
+    """
+
+
+class ScreenGroup(BaseModel):
+    r"""Nested group of clauses with its own operator (AND, OR, NOT)."""
+
+    clauses: Optional[List[ScreenClause]] = None
+    r"""Clauses combined by this group's operator."""
+
+    operator: Optional[ScreenGroupOperator] = None
+    r"""How the clauses inside this group are combined:
+    - `AND` — every clause in the group must match (logical AND).
+    - `OR` — at least one clause in the group must match (logical OR).
+    - `NOT` — negate the clause inside the group (logical NOT).
+    """
+
+    @field_serializer("operator")
+    def serialize_operator(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ScreenGroupOperator(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["clauses", "operator"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

finance_dev/models/searchetbsymbolsop.py

@@ -0,0 +1,40 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: a3b2095d32ba
+
+from __future__ import annotations
+from .etbsearchresponse import EtbSearchResponse, EtbSearchResponseTypedDict
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchEtbSymbolsResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    etb_search_response: NotRequired[EtbSearchResponseTypedDict]
+    r"""Borrowability answers keyed by normalized (uppercase) symbol. There is no 404: a symbol that is not on the list is a valid `false` answer, not a missing resource."""
+
+
+class SearchEtbSymbolsResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    etb_search_response: Optional[EtbSearchResponse] = None
+    r"""Borrowability answers keyed by normalized (uppercase) symbol. There is no 404: a symbol that is not on the list is a valid `false` answer, not a missing resource."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EtbSearchResponse"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

finance_dev/models/searchindicesop.py

@@ -0,0 +1,55 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: d3a556e6644a
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .indexsearchresponse import IndexSearchResponse, IndexSearchResponseTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, QueryParamMetadata
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchIndicesRequestTypedDict(TypedDict):
+    index_name: str
+    r"""Full or partial index name to search for. Case-insensitive substring match against the index display name (e.g. `S&P 500`, `Dow`, `NASDAQ`). Returns matching indices with their `symbol`, `indexGroup`, and `currency`."""
+
+
+class SearchIndicesRequest(BaseModel):
+    index_name: Annotated[
+        str,
+        pydantic.Field(alias="indexName"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ]
+    r"""Full or partial index name to search for. Case-insensitive substring match against the index display name (e.g. `S&P 500`, `Dow`, `NASDAQ`). Returns matching indices with their `symbol`, `indexGroup`, and `currency`."""
+
+
+class SearchIndicesResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    index_search_response: NotRequired[IndexSearchResponseTypedDict]
+    r"""Successful response"""
+
+
+class SearchIndicesResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    index_search_response: Optional[IndexSearchResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["IndexSearchResponse"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

finance_dev/models/searchlogosop.py

@@ -0,0 +1,158 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: a58135d5b066
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .logosearchresponse import LogoSearchResponse, LogoSearchResponseTypedDict
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, QueryParamMetadata
+import pydantic
+from pydantic import field_serializer, model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchLogosSearchKeysType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Tells the API how to interpret the value you send in `searchKeys`. Allowed values:
+    - `firm_id` — the value is a firm/company internal ID.
+    - `firm` — the value is the firm/company name.
+    """
+
+    SYMBOL = "symbol"
+    CIK = "cik"
+    CUSIP = "cusip"
+    ISIN = "isin"
+
+
+class SearchLogosRequestTypedDict(TypedDict):
+    search_keys: str
+    r"""One or more values to look up, comma-separated. The format depends on `searchKeysType`. For example, with `searchKeysType=symbol` send `AAPL,MSFT`; with `searchKeysType=cik` send `0000320193,0000789019`."""
+    fields: str
+    r"""Comma-separated list of logo asset fields to return. Common values:
+    - `logo_light` — full logo for light backgrounds.
+    - `logo_dark` — full logo for dark backgrounds.
+    - `mark_light` — square/icon mark for light backgrounds.
+    - `mark_dark` — square/icon mark for dark backgrounds.
+
+    Other provider-defined fields may also be supported — pass any field name the upstream image catalog exposes.
+    """
+    search_keys_type: NotRequired[SearchLogosSearchKeysType]
+    r"""Tells the API how to interpret the value you send in `searchKeys`. Allowed values:
+    - `firm_id` — the value is a firm/company internal ID.
+    - `firm` — the value is the firm/company name.
+    """
+    composite_auto: NotRequired[bool]
+    r"""Whether to auto-generate composite logo marks. Use true when you need fallback visuals for symbols without a standard logo."""
+    composite_radius: NotRequired[int]
+    r"""Corner radius for generated composite logos. Enter a value from 0 to 50 to match your UI style."""
+    scale: NotRequired[str]
+    r"""Image scale for returned logo URLs. Use higher scale values for high-density displays."""
+
+
+class SearchLogosRequest(BaseModel):
+    search_keys: Annotated[
+        str,
+        pydantic.Field(alias="searchKeys"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ]
+    r"""One or more values to look up, comma-separated. The format depends on `searchKeysType`. For example, with `searchKeysType=symbol` send `AAPL,MSFT`; with `searchKeysType=cik` send `0000320193,0000789019`."""
+
+    fields: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Comma-separated list of logo asset fields to return. Common values:
+    - `logo_light` — full logo for light backgrounds.
+    - `logo_dark` — full logo for dark backgrounds.
+    - `mark_light` — square/icon mark for light backgrounds.
+    - `mark_dark` — square/icon mark for dark backgrounds.
+
+    Other provider-defined fields may also be supported — pass any field name the upstream image catalog exposes.
+    """
+
+    search_keys_type: Annotated[
+        Optional[SearchLogosSearchKeysType],
+        pydantic.Field(alias="searchKeysType"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Tells the API how to interpret the value you send in `searchKeys`. Allowed values:
+    - `firm_id` — the value is a firm/company internal ID.
+    - `firm` — the value is the firm/company name.
+    """
+
+    composite_auto: Annotated[
+        Optional[bool],
+        pydantic.Field(alias="compositeAuto"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = False
+    r"""Whether to auto-generate composite logo marks. Use true when you need fallback visuals for symbols without a standard logo."""
+
+    composite_radius: Annotated[
+        Optional[int],
+        pydantic.Field(alias="compositeRadius"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Corner radius for generated composite logos. Enter a value from 0 to 50 to match your UI style."""
+
+    scale: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Image scale for returned logo URLs. Use higher scale values for high-density displays."""
+
+    @field_serializer("search_keys_type")
+    def serialize_search_keys_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SearchLogosSearchKeysType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["searchKeysType", "compositeAuto", "compositeRadius", "scale"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class SearchLogosResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    logo_search_response: NotRequired[LogoSearchResponseTypedDict]
+    r"""Successful response"""
+
+
+class SearchLogosResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    logo_search_response: Optional[LogoSearchResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["LogoSearchResponse"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

finance_dev/models/searchmarketsymbolsop.py

@@ -0,0 +1,80 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 91ef950abcee
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .searchsymbolresponseitem import (
+    SearchSymbolResponseItem,
+    SearchSymbolResponseItemTypedDict,
+)
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, QueryParamMetadata
+import pydantic
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchMarketSymbolsRequestTypedDict(TypedDict):
+    query: str
+    r"""Text the user entered in symbol search. Use `AAPL` for stocks and indices, `.AAPL` for option-chain style searches, and `/ES` for futures. Do not use `!` as a special prefix; it is treated as literal text."""
+    limit: NotRequired[int]
+    r"""Maximum number of matches to return. Use a small number for autocomplete and a larger number for full search pages. Default is 20; minimum is 1; maximum is 100."""
+
+
+class SearchMarketSymbolsRequest(BaseModel):
+    query: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Text the user entered in symbol search. Use `AAPL` for stocks and indices, `.AAPL` for option-chain style searches, and `/ES` for futures. Do not use `!` as a special prefix; it is treated as literal text."""
+
+    limit: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 20
+    r"""Maximum number of matches to return. Use a small number for autocomplete and a larger number for full search pages. Default is 20; minimum is 1; maximum is 100."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["limit"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class SearchMarketSymbolsResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    search_symbol_response: NotRequired[List[SearchSymbolResponseItemTypedDict]]
+    r"""Search results retrieved successfully"""
+
+
+class SearchMarketSymbolsResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    search_symbol_response: Optional[List[SearchSymbolResponseItem]] = None
+    r"""Search results retrieved successfully"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["SearchSymbolResponse"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

finance_dev/models/searchop.py

@@ -0,0 +1,232 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4189fcac8df5
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .predmdbaseeventsearchresult import (
+    PredMdBaseEventSearchResult,
+    PredMdBaseEventSearchResultTypedDict,
+)
+from .predmdcontractsearchresult import (
+    PredMdContractSearchResult,
+    PredMdContractSearchResultTypedDict,
+)
+from .predmdeventsearchresult import (
+    PredMdEventSearchResult,
+    PredMdEventSearchResultTypedDict,
+)
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, QueryParamMetadata, get_discriminator
+import pydantic
+from pydantic import Discriminator, Tag, field_serializer, model_serializer
+from typing import Callable, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class SearchType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Level hits come back at. `contracts` (default) returns matching contracts; `events` returns one hit per event and `base-events` one per base event, each ranked by its best-matching contract and carrying only its own fields and a count of matching contracts. Echoed in the response."""
+
+    CONTRACTS = "contracts"
+    EVENTS = "events"
+    BASE_EVENTS = "base-events"
+
+
+class SearchRequestTypedDict(TypedDict):
+    type: NotRequired[SearchType]
+    r"""Level hits come back at. `contracts` (default) returns matching contracts; `events` returns one hit per event and `base-events` one per base event, each ranked by its best-matching contract and carrying only its own fields and a count of matching contracts. Echoed in the response."""
+    q: NotRequired[str]
+    r"""Full-text query over symbols, questions, event names and base-event specifications. Symbols split on _, - and . so `BPM 0822` finds `BPM_0822_1750`. Omit to browse, soonest last-trade date first."""
+    state: NotRequired[str]
+    r"""Contract state. Omitted means ACTIVE; `*` matches every state, including DELETED."""
+    base_event_id: NotRequired[str]
+    r"""Only contracts under this base event."""
+    event_id: NotRequired[str]
+    r"""Only contracts under this event."""
+    category: NotRequired[str]
+    r"""Only contracts in this category or any category under it. Takes a `path` from List Categories, URL-encoded. A bare level name such as `United States` matches nothing, because level names repeat under different parents."""
+    tradable: NotRequired[bool]
+    r"""Only tradable (true) or non-tradable (false) contracts."""
+    page: NotRequired[int]
+    r"""1-based page number; 0 or omitted means 1."""
+    per_page: NotRequired[int]
+    r"""Hits per page, counting whatever type returns; 0 or omitted means 20, values above 100 are clamped to 100."""
+
+
+class SearchRequest(BaseModel):
+    type: Annotated[
+        Optional[SearchType],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = SearchType.CONTRACTS
+    r"""Level hits come back at. `contracts` (default) returns matching contracts; `events` returns one hit per event and `base-events` one per base event, each ranked by its best-matching contract and carrying only its own fields and a count of matching contracts. Echoed in the response."""
+
+    q: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Full-text query over symbols, questions, event names and base-event specifications. Symbols split on _, - and . so `BPM 0822` finds `BPM_0822_1750`. Omit to browse, soonest last-trade date first."""
+
+    state: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Contract state. Omitted means ACTIVE; `*` matches every state, including DELETED."""
+
+    base_event_id: Annotated[
+        Optional[str],
+        pydantic.Field(alias="baseEventId"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Only contracts under this base event."""
+
+    event_id: Annotated[
+        Optional[str],
+        pydantic.Field(alias="eventId"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Only contracts under this event."""
+
+    category: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Only contracts in this category or any category under it. Takes a `path` from List Categories, URL-encoded. A bare level name such as `United States` matches nothing, because level names repeat under different parents."""
+
+    tradable: Annotated[
+        Optional[bool],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Only tradable (true) or non-tradable (false) contracts."""
+
+    page: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""1-based page number; 0 or omitted means 1."""
+
+    per_page: Annotated[
+        Optional[int],
+        pydantic.Field(alias="perPage"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Hits per page, counting whatever type returns; 0 or omitted means 20, values above 100 are clamped to 100."""
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SearchType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "type",
+                "q",
+                "state",
+                "baseEventId",
+                "eventId",
+                "category",
+                "tradable",
+                "page",
+                "perPage",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+SearchDataTypedDict = TypeAliasType(
+    "SearchDataTypedDict",
+    Union[
+        PredMdContractSearchResultTypedDict,
+        PredMdEventSearchResultTypedDict,
+        PredMdBaseEventSearchResultTypedDict,
+    ],
+)
+
+
+SearchData = Annotated[
+    Union[
+        Annotated[PredMdBaseEventSearchResult, Tag("base-events")],
+        Annotated[PredMdContractSearchResult, Tag("contracts")],
+        Annotated[PredMdEventSearchResult, Tag("events")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+class SearchResponseBodyTypedDict(TypedDict):
+    r"""Standard success envelope used by all success responses. `data` is endpoint-specific."""
+
+    success: bool
+    data: NotRequired[SearchDataTypedDict]
+
+
+class SearchResponseBody(BaseModel):
+    r"""Standard success envelope used by all success responses. `data` is endpoint-specific."""
+
+    success: bool
+
+    data: Optional[SearchData] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class SearchResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    object: NotRequired[SearchResponseBodyTypedDict]
+    r"""One page of hits; data.type says which shape they are"""
+
+
+class SearchResponse(BaseModel):
+    next: Callable[[], Optional[SearchResponse]]
+
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    object: Optional[SearchResponseBody] = None
+    r"""One page of hits; data.type says which shape they are"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["object"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m