finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/getstocksnapshotsop.py

@@ -0,0 +1,82 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4622e92023e1
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .stocksnapshotsresponse import (
+    StockSnapshotsResponse,
+    StockSnapshotsResponseTypedDict,
+)
+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 GetStockSnapshotsRequestTypedDict(TypedDict):
+    tickers: NotRequired[str]
+    r"""Comma-separated list of tickers, such as AAPL,MSFT. Use this to request several companies in one call."""
+    include_otc: NotRequired[bool]
+    r"""Whether to include over-the-counter securities. Use true only when your product needs OTC market coverage."""
+
+
+class GetStockSnapshotsRequest(BaseModel):
+    tickers: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Comma-separated list of tickers, such as AAPL,MSFT. Use this to request several companies in one call."""
+
+    include_otc: Annotated[
+        Optional[bool],
+        pydantic.Field(alias="includeOtc"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Whether to include over-the-counter securities. Use true only when your product needs OTC market coverage."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["tickers", "includeOtc"])
+        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 GetStockSnapshotsResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    stock_snapshots_response: NotRequired[StockSnapshotsResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetStockSnapshotsResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    stock_snapshots_response: Optional[StockSnapshotsResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["StockSnapshotsResponse"])
+        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/getstocksplitsop.py

@@ -0,0 +1,243 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f5fbdb6c6f0e
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .stocksplitsresponse import StockSplitsResponse, StockSplitsResponseTypedDict
+from datetime import date
+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 Callable, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class GetStockSplitsAdjustmentType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Exact type: forward_split, reverse_split, stock_dividend"""
+
+    FORWARD_SPLIT = "forward_split"
+    REVERSE_SPLIT = "reverse_split"
+    STOCK_DIVIDEND = "stock_dividend"
+
+
+class GetStockSplitsRequestTypedDict(TypedDict):
+    ticker: NotRequired[str]
+    r"""Single ticker symbol only, such as AAPL. Do not send a comma-separated list here; if you need multiple symbols, use `tickersAnyOf` instead."""
+    tickers_any_of: NotRequired[str]
+    r"""Comma-separated list of ticker symbols."""
+    ticker_from: NotRequired[str]
+    r"""Filter tickers >= this value (inclusive)"""
+    ticker_after: NotRequired[str]
+    r"""Filter tickers > this value (exclusive)"""
+    ticker_to: NotRequired[str]
+    r"""Filter tickers <= this value (inclusive)"""
+    ticker_before: NotRequired[str]
+    r"""Filter tickers < this value (exclusive)"""
+    execution_date: NotRequired[date]
+    r"""Exact execution date in YYYY-MM-DD format"""
+    execution_date_from: NotRequired[date]
+    r"""Filter to splits that executed on or after this date (inclusive). Format: `YYYY-MM-DD`."""
+    execution_date_after: NotRequired[date]
+    r"""Filter to splits that executed strictly after this date (exclusive). Format: `YYYY-MM-DD`."""
+    execution_date_to: NotRequired[date]
+    r"""Filter to splits that executed on or before this date (inclusive). Format: `YYYY-MM-DD`."""
+    execution_date_before: NotRequired[date]
+    r"""Filter to splits that executed strictly before this date (exclusive). Format: `YYYY-MM-DD`."""
+    adjustment_type: NotRequired[GetStockSplitsAdjustmentType]
+    r"""Exact type: forward_split, reverse_split, stock_dividend"""
+    adjustment_types: NotRequired[str]
+    r"""Comma-separated list of adjustment types"""
+    limit: NotRequired[int]
+    r"""Maximum number of results to return. Range: 1 to 5000. Use smaller values for UI pages, larger for batch exports."""
+    sort: NotRequired[str]
+    r"""A comma-separated list of sort columns. For each column, append `.asc` or `.desc` to specify direction. Defaults to `ticker.asc` when not specified. Examples: `execution_date.desc` or `ticker.asc,execution_date.desc`."""
+    next: NotRequired[str]
+    r"""Pagination cursor from previous response"""
+
+
+class GetStockSplitsRequest(BaseModel):
+    ticker: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Single ticker symbol only, such as AAPL. Do not send a comma-separated list here; if you need multiple symbols, use `tickersAnyOf` instead."""
+
+    tickers_any_of: Annotated[
+        Optional[str],
+        pydantic.Field(alias="tickersAnyOf"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Comma-separated list of ticker symbols."""
+
+    ticker_from: Annotated[
+        Optional[str],
+        pydantic.Field(alias="tickerFrom"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter tickers >= this value (inclusive)"""
+
+    ticker_after: Annotated[
+        Optional[str],
+        pydantic.Field(alias="tickerAfter"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter tickers > this value (exclusive)"""
+
+    ticker_to: Annotated[
+        Optional[str],
+        pydantic.Field(alias="tickerTo"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter tickers <= this value (inclusive)"""
+
+    ticker_before: Annotated[
+        Optional[str],
+        pydantic.Field(alias="tickerBefore"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter tickers < this value (exclusive)"""
+
+    execution_date: Annotated[
+        Optional[date],
+        pydantic.Field(alias="executionDate"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Exact execution date in YYYY-MM-DD format"""
+
+    execution_date_from: Annotated[
+        Optional[date],
+        pydantic.Field(alias="executionDateFrom"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter to splits that executed on or after this date (inclusive). Format: `YYYY-MM-DD`."""
+
+    execution_date_after: Annotated[
+        Optional[date],
+        pydantic.Field(alias="executionDateAfter"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter to splits that executed strictly after this date (exclusive). Format: `YYYY-MM-DD`."""
+
+    execution_date_to: Annotated[
+        Optional[date],
+        pydantic.Field(alias="executionDateTo"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter to splits that executed on or before this date (inclusive). Format: `YYYY-MM-DD`."""
+
+    execution_date_before: Annotated[
+        Optional[date],
+        pydantic.Field(alias="executionDateBefore"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Filter to splits that executed strictly before this date (exclusive). Format: `YYYY-MM-DD`."""
+
+    adjustment_type: Annotated[
+        Optional[GetStockSplitsAdjustmentType],
+        pydantic.Field(alias="adjustmentType"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Exact type: forward_split, reverse_split, stock_dividend"""
+
+    adjustment_types: Annotated[
+        Optional[str],
+        pydantic.Field(alias="adjustmentTypes"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Comma-separated list of adjustment types"""
+
+    limit: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Maximum number of results to return. Range: 1 to 5000. Use smaller values for UI pages, larger for batch exports."""
+
+    sort: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""A comma-separated list of sort columns. For each column, append `.asc` or `.desc` to specify direction. Defaults to `ticker.asc` when not specified. Examples: `execution_date.desc` or `ticker.asc,execution_date.desc`."""
+
+    next: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Pagination cursor from previous response"""
+
+    @field_serializer("adjustment_type")
+    def serialize_adjustment_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.GetStockSplitsAdjustmentType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "ticker",
+                "tickersAnyOf",
+                "tickerFrom",
+                "tickerAfter",
+                "tickerTo",
+                "tickerBefore",
+                "executionDate",
+                "executionDateFrom",
+                "executionDateAfter",
+                "executionDateTo",
+                "executionDateBefore",
+                "adjustmentType",
+                "adjustmentTypes",
+                "limit",
+                "sort",
+                "next",
+            ]
+        )
+        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 GetStockSplitsResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    stock_splits_response: NotRequired[StockSplitsResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetStockSplitsResponse(BaseModel):
+    next: Callable[[], Optional[GetStockSplitsResponse]]
+
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    stock_splits_response: Optional[StockSplitsResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["StockSplitsResponse"])
+        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/getstocktradesop.py

@@ -0,0 +1,177 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 7f4b9336fedd
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .stocktradesresponse import StockTradesResponse, StockTradesResponseTypedDict
+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 Callable, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class GetStockTradesOrder(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Sort order for returned records. Use asc for oldest first or desc for newest first when supported."""
+
+    ASC = "asc"
+    DESC = "desc"
+
+
+class GetStockTradesRequestTypedDict(TypedDict):
+    ticker: str
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+    timestamp: NotRequired[str]
+    r"""Query by timestamp (YYYY-MM-DD or nanoseconds)"""
+    timestamp_from: NotRequired[str]
+    r"""Timestamp start filter. Returns records at or after this timestamp."""
+    timestamp_after: NotRequired[str]
+    r"""Timestamp lower-bound filter. Returns records after this timestamp, excluding the timestamp itself."""
+    timestamp_to: NotRequired[str]
+    r"""Timestamp end filter. Returns records at or before this timestamp."""
+    timestamp_before: NotRequired[str]
+    r"""Timestamp upper-bound filter. Returns records before this timestamp, excluding the timestamp itself."""
+    order: NotRequired[GetStockTradesOrder]
+    r"""Sort order for returned records. Use asc for oldest first or desc for newest first when supported."""
+    limit: NotRequired[int]
+    r"""Maximum number of results to return. Use smaller values for UI pages and larger values for exports within API limits."""
+    sort: NotRequired[str]
+    r"""Sort field used for ordering. Massive documents this separately from `order`, so enter the provider-supported field name in the text box, for example `timestamp`."""
+    next: NotRequired[str]
+    r"""Pagination cursor from the previous response. Omit it on the first request, then send the returned cursor to fetch the next page."""
+
+
+class GetStockTradesRequest(BaseModel):
+    ticker: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+    timestamp: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Query by timestamp (YYYY-MM-DD or nanoseconds)"""
+
+    timestamp_from: Annotated[
+        Optional[str],
+        pydantic.Field(alias="timestampFrom"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Timestamp start filter. Returns records at or after this timestamp."""
+
+    timestamp_after: Annotated[
+        Optional[str],
+        pydantic.Field(alias="timestampAfter"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Timestamp lower-bound filter. Returns records after this timestamp, excluding the timestamp itself."""
+
+    timestamp_to: Annotated[
+        Optional[str],
+        pydantic.Field(alias="timestampTo"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Timestamp end filter. Returns records at or before this timestamp."""
+
+    timestamp_before: Annotated[
+        Optional[str],
+        pydantic.Field(alias="timestampBefore"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Timestamp upper-bound filter. Returns records before this timestamp, excluding the timestamp itself."""
+
+    order: Annotated[
+        Optional[GetStockTradesOrder],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = GetStockTradesOrder.DESC
+    r"""Sort order for returned records. Use asc for oldest first or desc for newest first when supported."""
+
+    limit: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Maximum number of results to return. Use smaller values for UI pages and larger values for exports within API limits."""
+
+    sort: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Sort field used for ordering. Massive documents this separately from `order`, so enter the provider-supported field name in the text box, for example `timestamp`."""
+
+    next: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Pagination cursor from the previous response. Omit it on the first request, then send the returned cursor to fetch the next page."""
+
+    @field_serializer("order")
+    def serialize_order(self, value):
+        if isinstance(value, str):
+            try:
+                return models.GetStockTradesOrder(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "timestamp",
+                "timestampFrom",
+                "timestampAfter",
+                "timestampTo",
+                "timestampBefore",
+                "order",
+                "limit",
+                "sort",
+                "next",
+            ]
+        )
+        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 GetStockTradesResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    stock_trades_response: NotRequired[StockTradesResponseTypedDict]
+    r"""Successful response"""
+
+
+class GetStockTradesResponse(BaseModel):
+    next: Callable[[], Optional[GetStockTradesResponse]]
+
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    stock_trades_response: Optional[StockTradesResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["StockTradesResponse"])
+        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/getsupplychainop.py

@@ -0,0 +1,53 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 605c8d9e80dd
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .supplychainresponse import SupplyChainResponse, SupplyChainResponseTypedDict
+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 GetSupplyChainRequestTypedDict(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`."""
+
+
+class GetSupplyChainRequest(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`."""
+
+
+class GetSupplyChainResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    supply_chain_response: NotRequired[SupplyChainResponseTypedDict]
+    r"""Supply chain data."""
+
+
+class GetSupplyChainResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    supply_chain_response: Optional[SupplyChainResponse] = None
+    r"""Supply chain data."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["SupplyChainResponse"])
+        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/getsupportresistancelevelsop.py

@@ -0,0 +1,90 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: a985700ee8b1
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .supportresistancelevelsresponse import (
+    SupportResistanceLevelsResponse,
+    SupportResistanceLevelsResponseTypedDict,
+)
+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 GetSupportResistanceLevelsResolution(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How long each bar covers. Supported values are minutes (`1`, `5`, `15`, `30`, `60`) or daily/weekly/monthly (`D`, `W`, `M`). Other values return 400 Bad Request with error code `VALIDATION_ERROR`."""
+
+    ONE = "1"
+    FIVE = "5"
+    FIFTEEN = "15"
+    THIRTY = "30"
+    SIXTY = "60"
+    D = "D"
+    W = "W"
+    M = "M"
+
+
+class GetSupportResistanceLevelsRequestTypedDict(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`."""
+    resolution: GetSupportResistanceLevelsResolution
+    r"""How long each bar covers. Supported values are minutes (`1`, `5`, `15`, `30`, `60`) or daily/weekly/monthly (`D`, `W`, `M`). Other values return 400 Bad Request with error code `VALIDATION_ERROR`."""
+
+
+class GetSupportResistanceLevelsRequest(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`."""
+
+    resolution: Annotated[
+        GetSupportResistanceLevelsResolution,
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ]
+    r"""How long each bar covers. Supported values are minutes (`1`, `5`, `15`, `30`, `60`) or daily/weekly/monthly (`D`, `W`, `M`). Other values return 400 Bad Request with error code `VALIDATION_ERROR`."""
+
+    @field_serializer("resolution")
+    def serialize_resolution(self, value):
+        if isinstance(value, str):
+            try:
+                return models.GetSupportResistanceLevelsResolution(value)
+            except ValueError:
+                return value
+        return value
+
+
+class GetSupportResistanceLevelsResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    support_resistance_levels_response: NotRequired[
+        SupportResistanceLevelsResponseTypedDict
+    ]
+    r"""Successful response"""
+
+
+class GetSupportResistanceLevelsResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    support_resistance_levels_response: Optional[SupportResistanceLevelsResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["SupportResistanceLevelsResponse"])
+        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