finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/getearningscallliveop.py

@@ -0,0 +1,91 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ef4e0c2a97a1
+
+from __future__ import annotations
+from .earningscallliveresponse import (
+    EarningsCallLiveResponse,
+    EarningsCallLiveResponseTypedDict,
+)
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from datetime import date
+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 GetEarningsCallLiveRequestTypedDict(TypedDict):
+    from_: NotRequired[date]
+    r"""Start of the date window, inclusive. Format: `YYYY-MM-DD`."""
+    to: NotRequired[date]
+    r"""End of the date window, inclusive. Format: `YYYY-MM-DD`."""
+    symbol: NotRequired[str]
+    r"""Stock ticker to query. Send the plain uppercase symbol, e.g. `AAPL`."""
+
+
+class GetEarningsCallLiveRequest(BaseModel):
+    from_: Annotated[
+        Optional[date],
+        pydantic.Field(alias="from"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Start of the date window, inclusive. Format: `YYYY-MM-DD`."""
+
+    to: Annotated[
+        Optional[date],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""End of the date window, inclusive. Format: `YYYY-MM-DD`."""
+
+    symbol: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Stock ticker to query. Send the plain uppercase symbol, e.g. `AAPL`."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["from", "to", "symbol"])
+        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 GetEarningsCallLiveResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    earnings_call_live_response: NotRequired[EarningsCallLiveResponseTypedDict]
+    r"""Earnings call live data."""
+
+
+class GetEarningsCallLiveResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    earnings_call_live_response: Optional[EarningsCallLiveResponse] = None
+    r"""Earnings call live data."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EarningsCallLiveResponse"])
+        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/getearningsqualityscoreop.py

@@ -0,0 +1,81 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: fe4e32852472
+
+from __future__ import annotations
+from .earningsqualityscoreresponse import (
+    EarningsQualityScoreResponse,
+    EarningsQualityScoreResponseTypedDict,
+)
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .reportingfrequency import ReportingFrequency
+from finance_dev import models
+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 GetEarningsQualityScoreRequestTypedDict(TypedDict):
+    symbol: str
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`."""
+    freq: ReportingFrequency
+    r"""How often the score is computed. Allowed values:
+    - `annual` — one score per fiscal year (broad trends).
+    - `quarterly` — one score per quarter (closer to recent reporting).
+    """
+
+
+class GetEarningsQualityScoreRequest(BaseModel):
+    symbol: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`."""
+
+    freq: Annotated[
+        ReportingFrequency,
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ]
+    r"""How often the score is computed. Allowed values:
+    - `annual` — one score per fiscal year (broad trends).
+    - `quarterly` — one score per quarter (closer to recent reporting).
+    """
+
+    @field_serializer("freq")
+    def serialize_freq(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportingFrequency(value)
+            except ValueError:
+                return value
+        return value
+
+
+class GetEarningsQualityScoreResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    earnings_quality_score_response: NotRequired[EarningsQualityScoreResponseTypedDict]
+    r"""Earnings quality score data."""
+
+
+class GetEarningsQualityScoreResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    earnings_quality_score_response: Optional[EarningsQualityScoreResponse] = None
+    r"""Earnings quality score data."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EarningsQualityScoreResponse"])
+        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/getearningssurprisesop.py

@@ -0,0 +1,80 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: e8887a50d232
+
+from __future__ import annotations
+from .earningssurprisesresponse import (
+    EarningsSurprisesResponse,
+    EarningsSurprisesResponseTypedDict,
+)
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+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 GetEarningsSurprisesRequestTypedDict(TypedDict):
+    symbol: str
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+    limit: NotRequired[int]
+    r"""(Optional) Number of results to return"""
+
+
+class GetEarningsSurprisesRequest(BaseModel):
+    symbol: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+
+    limit: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""(Optional) Number of results to return"""
+
+    @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 GetEarningsSurprisesResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    earnings_surprises_response: NotRequired[EarningsSurprisesResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetEarningsSurprisesResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    earnings_surprises_response: Optional[EarningsSurprisesResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EarningsSurprisesResponse"])
+        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/getebitdaestimatesop.py

@@ -0,0 +1,91 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: db29650d239f
+
+from __future__ import annotations
+from .ebitdaestimatesresponse import (
+    EbitdaEstimatesResponse,
+    EbitdaEstimatesResponseTypedDict,
+)
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .reportingfrequency import ReportingFrequency
+from finance_dev import models
+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 GetEbitdaEstimatesRequestTypedDict(TypedDict):
+    symbol: str
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+    freq: NotRequired[ReportingFrequency]
+    r"""(Optional) Frequency: annual, quarterly"""
+
+
+class GetEbitdaEstimatesRequest(BaseModel):
+    symbol: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+
+    freq: Annotated[
+        Optional[ReportingFrequency],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""(Optional) Frequency: annual, quarterly"""
+
+    @field_serializer("freq")
+    def serialize_freq(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportingFrequency(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["freq"])
+        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 GetEbitdaEstimatesResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    ebitda_estimates_response: NotRequired[EbitdaEstimatesResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetEbitdaEstimatesResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    ebitda_estimates_response: Optional[EbitdaEstimatesResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EbitdaEstimatesResponse"])
+        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/getebitestimatesop.py

@@ -0,0 +1,88 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 33024049b6d4
+
+from __future__ import annotations
+from .ebitestimatesresponse import EbitEstimatesResponse, EbitEstimatesResponseTypedDict
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .reportingfrequency import ReportingFrequency
+from finance_dev import models
+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 GetEbitEstimatesRequestTypedDict(TypedDict):
+    symbol: str
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+    freq: NotRequired[ReportingFrequency]
+    r"""(Optional) Frequency: annual, quarterly"""
+
+
+class GetEbitEstimatesRequest(BaseModel):
+    symbol: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+
+    freq: Annotated[
+        Optional[ReportingFrequency],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""(Optional) Frequency: annual, quarterly"""
+
+    @field_serializer("freq")
+    def serialize_freq(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportingFrequency(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["freq"])
+        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 GetEbitEstimatesResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    ebit_estimates_response: NotRequired[EbitEstimatesResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetEbitEstimatesResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    ebit_estimates_response: Optional[EbitEstimatesResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EbitEstimatesResponse"])
+        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/geteconomicscalendarop.py

@@ -0,0 +1,92 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 70e33970b6f6
+
+from __future__ import annotations
+from .geteconomicscalendarresponse import (
+    GetEconomicsCalendarResponse,
+    GetEconomicsCalendarResponseTypedDict,
+)
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from datetime import date
+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 GetEconomicsCalendarRequestTypedDict(TypedDict):
+    date_: NotRequired[date]
+    r"""Single date in YYYY-MM-DD format. Returns events for that date plus 1 month ahead. Either 'date' or 'from' must be provided."""
+    from_: NotRequired[date]
+    r"""Start date of range in YYYY-MM-DD format. Must be used with 'to'. Either 'date' or 'from' must be provided."""
+    to: NotRequired[date]
+    r"""End date of range in YYYY-MM-DD format. Required when 'from' is specified."""
+
+
+class GetEconomicsCalendarRequest(BaseModel):
+    date_: Annotated[
+        Optional[date],
+        pydantic.Field(alias="date"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Single date in YYYY-MM-DD format. Returns events for that date plus 1 month ahead. Either 'date' or 'from' must be provided."""
+
+    from_: Annotated[
+        Optional[date],
+        pydantic.Field(alias="from"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Start date of range in YYYY-MM-DD format. Must be used with 'to'. Either 'date' or 'from' must be provided."""
+
+    to: Annotated[
+        Optional[date],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""End date of range in YYYY-MM-DD format. Required when 'from' is specified."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["date", "from", "to"])
+        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 GetEconomicsCalendarResponseResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    get_economics_calendar_response: NotRequired[GetEconomicsCalendarResponseTypedDict]
+    r"""Economics calendar events retrieved successfully"""
+
+
+class GetEconomicsCalendarResponseResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    get_economics_calendar_response: Optional[GetEconomicsCalendarResponse] = None
+    r"""Economics calendar events retrieved successfully"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["GetEconomicsCalendarResponse"])
+        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/geteconomicscalendarresponse.py

@@ -0,0 +1,56 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 658f9977a93c
+
+from __future__ import annotations
+from .economicscalendarevent import (
+    EconomicsCalendarEvent,
+    EconomicsCalendarEventTypedDict,
+)
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class GetEconomicsCalendarResponseTypedDict(TypedDict):
+    r"""Economic calendar response for the requested date. Use it to show macroeconomic events that may affect markets."""
+
+    events: NotRequired[List[EconomicsCalendarEventTypedDict]]
+    r"""List of economic calendar events for the requested date"""
+    important_dates: NotRequired[List[str]]
+    r"""Optional list of notable dates"""
+
+
+class GetEconomicsCalendarResponse(BaseModel):
+    r"""Economic calendar response for the requested date. Use it to show macroeconomic events that may affect markets."""
+
+    events: Optional[List[EconomicsCalendarEvent]] = None
+    r"""List of economic calendar events for the requested date"""
+
+    important_dates: Annotated[
+        Optional[List[str]], pydantic.Field(alias="importantDates")
+    ] = None
+    r"""Optional list of notable dates"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["events", "importantDates"])
+        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
+
+
+try:
+    GetEconomicsCalendarResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/getepsestimatesop.py

@@ -0,0 +1,88 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: b844cf88ae11
+
+from __future__ import annotations
+from .epsestimatesresponse import EpsEstimatesResponse, EpsEstimatesResponseTypedDict
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .reportingfrequency import ReportingFrequency
+from finance_dev import models
+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 GetEpsEstimatesRequestTypedDict(TypedDict):
+    symbol: str
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+    freq: NotRequired[ReportingFrequency]
+    r"""(Optional) Frequency: annual, quarterly"""
+
+
+class GetEpsEstimatesRequest(BaseModel):
+    symbol: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Stock ticker to query. Send the plain uppercase symbol exactly as you'd type it on a brokerage screen, e.g. `AAPL`, `MSFT`, `TSLA`."""
+
+    freq: Annotated[
+        Optional[ReportingFrequency],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""(Optional) Frequency: annual, quarterly"""
+
+    @field_serializer("freq")
+    def serialize_freq(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportingFrequency(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["freq"])
+        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 GetEpsEstimatesResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    eps_estimates_response: NotRequired[EpsEstimatesResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetEpsEstimatesResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    eps_estimates_response: Optional[EpsEstimatesResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["EpsEstimatesResponse"])
+        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