finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/optiontradesresponse.py

@@ -0,0 +1,132 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f4c301dbf4db
+
+from __future__ import annotations
+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 OptionTradesResponseResultTypedDict(TypedDict):
+    conditions: NotRequired[List[int]]
+    r"""Trade conditions"""
+    correction: NotRequired[int]
+    r"""Correction indicator"""
+    exchange: NotRequired[int]
+    r"""Numeric exchange identifier supplied by the market data provider."""
+    participant_timestamp: NotRequired[int]
+    r"""Participant timestamp (nanoseconds)"""
+    price: NotRequired[float]
+    r"""Trade price"""
+    sip_timestamp: NotRequired[int]
+    r"""SIP timestamp (nanoseconds)"""
+    size: NotRequired[float]
+    r"""Trade size (contracts)"""
+
+
+class OptionTradesResponseResult(BaseModel):
+    conditions: Optional[List[int]] = None
+    r"""Trade conditions"""
+
+    correction: Optional[int] = None
+    r"""Correction indicator"""
+
+    exchange: Optional[int] = None
+    r"""Numeric exchange identifier supplied by the market data provider."""
+
+    participant_timestamp: Annotated[
+        Optional[int], pydantic.Field(alias="participantTimestamp")
+    ] = None
+    r"""Participant timestamp (nanoseconds)"""
+
+    price: Optional[float] = None
+    r"""Trade price"""
+
+    sip_timestamp: Annotated[Optional[int], pydantic.Field(alias="sipTimestamp")] = None
+    r"""SIP timestamp (nanoseconds)"""
+
+    size: Optional[float] = None
+    r"""Trade size (contracts)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "conditions",
+                "correction",
+                "exchange",
+                "participantTimestamp",
+                "price",
+                "sipTimestamp",
+                "size",
+            ]
+        )
+        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 OptionTradesResponseTypedDict(TypedDict):
+    r"""Paginated list of historical tick-level trades for an options contract."""
+
+    next_url: NotRequired[str]
+    r"""URL for next page of results"""
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[List[OptionTradesResponseResultTypedDict]]
+    r"""Array of options trade objects"""
+    status: NotRequired[str]
+    r"""Status string from the upstream data provider — typically `OK` for a successful response. Treat any other value as an error indicator alongside the HTTP status code."""
+
+
+class OptionTradesResponse(BaseModel):
+    r"""Paginated list of historical tick-level trades for an options contract."""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""URL for next page of results"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Unique request ID"""
+
+    results: Optional[List[OptionTradesResponseResult]] = None
+    r"""Array of options trade objects"""
+
+    status: Optional[str] = None
+    r"""Status string from the upstream data provider — typically `OK` for a successful response. Treat any other value as an error indicator alongside the HTTP status code."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["nextUrl", "requestId", "results", "status"])
+        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:
+    OptionTradesResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    OptionTradesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/orderrequesttimeinforceenum.py

@@ -0,0 +1,29 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: bd06a8335409
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class OrderRequestTimeInForceEnum(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How long the order should stay alive before automatically cancelling. Pick one:
+    - `DAY` — Active until the end of today's regular trading session, then cancelled if not filled. The default choice for most orders.
+    - `GTC` — Good 'Til Cancelled. Stays open across multiple trading days until you cancel it (the broker may cap at 60–90 days).
+    - `IOC` — Immediate Or Cancel. Fill whatever you can right now; cancel the rest immediately. Useful when you want partial fills but no resting order.
+    - `FOK` — Fill Or Kill. Fill the entire order immediately, or cancel it entirely. No partial fills allowed.
+    - `EXTENDED_HOURS` — Active during pre-market and after-hours trading sessions in addition to regular hours.
+    - `AT_THE_OPENING` — Execute at the official market open price; if it can't fill at open, it's cancelled.
+    - `AT_THE_CLOSE` — Execute at the official market close price; if it can't fill at close, it's cancelled.
+    """
+
+    DAY = "DAY"
+    GTC = "GTC"
+    IOC = "IOC"
+    FOK = "FOK"
+    EXTENDED_HOURS = "EXTENDED_HOURS"
+    AT_THE_OPENING = "AT_THE_OPENING"
+    AT_THE_CLOSE = "AT_THE_CLOSE"
+    ATO = "ATO"
+    ATC = "ATC"
+    EXT = "EXT"

finance_dev/models/ordersideenum.py

@@ -0,0 +1,20 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5a18309858ca
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class OrderSideEnum(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Which direction to trade in. Pick one:
+    - `BUY` — buying shares or contracts (opens a long position or closes an existing short).
+    - `SELL` — selling shares or contracts you already hold (closes a long position).
+    - `SELL_SHORT` — selling shares you do not own (opens a short position). Subject to short-sale regulations.
+    - `BUY_TO_COVER` — buying shares to close an open short position.
+    """
+
+    BUY = "BUY"
+    SELL = "SELL"
+    SELL_SHORT = "SELL_SHORT"
+    BUY_TO_COVER = "BUY_TO_COVER"

finance_dev/models/ordertypeenum.py

@@ -0,0 +1,20 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 92afaf43c525
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class OrderTypeEnum(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How the order is priced. Pick one:
+    - `MARKET` — Execute immediately at the best available price. Fast and guaranteed to fill, but no price guarantee — the actual fill price can move during execution.
+    - `LIMIT` — Execute only at the limit `price` or better (lower for buys, higher for sells). Gives you price control, no execution guarantee. Requires the `price` field.
+    - `STOP` — Sits inactive until the market hits `stopPrice`, then converts to a market order. Common for stop-loss exits. Requires the `stopPrice` field.
+    - `STOP_LIMIT` — Sits inactive until the market hits `stopPrice`, then converts to a limit order at `price`. More control than `STOP`, but the limit may not fill. Requires both `stopPrice` and `price`.
+    """
+
+    MARKET = "MARKET"
+    LIMIT = "LIMIT"
+    STOP = "STOP"
+    STOP_LIMIT = "STOP_LIMIT"

finance_dev/models/ordleg.py

@@ -0,0 +1,162 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: e736ea529ce7
+
+from __future__ import annotations
+from .securitytypeenum import SecurityTypeEnum
+from datetime import date
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import field_serializer, model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OrdLegPositionEffect(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Whether this leg opens or closes a position. Use `OPEN` for a new position and `CLOSE` when closing an existing position."""
+
+    O = "O"
+    C = "C"
+    OPEN = "OPEN"
+    CLOSE = "CLOSE"
+
+
+class OrdLegPutCall(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Option contract type. Use `CALL` for call options and `PUT` for put options."""
+
+    PUT = "PUT"
+    CALL = "CALL"
+    P = "P"
+    C = "C"
+
+
+class OrdLegSide(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Direction for this option leg. Use `BUY` when buying the leg and `SELL` when selling the leg."""
+
+    B = "B"
+    S = "S"
+    BUY = "BUY"
+    SELL = "SELL"
+
+
+class OrdLegTypedDict(TypedDict):
+    r"""One option leg inside a single-leg or multi-leg order. Use this only for option orders; omit `legs` for normal stock orders."""
+
+    position_effect: OrdLegPositionEffect
+    r"""Whether this leg opens or closes a position. Use `OPEN` for a new position and `CLOSE` when closing an existing position."""
+    ratio_qty: str
+    r"""Leg ratio quantity as a decimal string. Use \"1\" for a standard one-to-one leg; use other ratios for spreads that require uneven leg sizing."""
+    security_type: SecurityTypeEnum
+    r"""What kind of instrument the order is for. Pick one:
+    - `CS` — Common Stock (equity / ETF).
+    - `OPT` — Option contract (call or put).
+    """
+    side: OrdLegSide
+    r"""Direction for this option leg. Use `BUY` when buying the leg and `SELL` when selling the leg."""
+    cfi_code: NotRequired[str]
+    r"""Optional CFI code if your system uses ISO instrument classification. Most integrations can omit this unless their option workflow requires it."""
+    maturity: NotRequired[date]
+    r"""Option expiration date in YYYY-MM-DD format. Required for option legs when the contract is not fully identified elsewhere."""
+    put_call: NotRequired[OrdLegPutCall]
+    r"""Option contract type. Use `CALL` for call options and `PUT` for put options."""
+    strike_price: NotRequired[str]
+    r"""Option strike price as a decimal string. Required for option legs when the contract is not fully identified elsewhere."""
+    symbol: NotRequired[str]
+    r"""Underlying symbol for this option leg. Omit it when the leg uses the same underlying as the order-level symbol."""
+
+
+class OrdLeg(BaseModel):
+    r"""One option leg inside a single-leg or multi-leg order. Use this only for option orders; omit `legs` for normal stock orders."""
+
+    position_effect: Annotated[
+        OrdLegPositionEffect, pydantic.Field(alias="positionEffect")
+    ]
+    r"""Whether this leg opens or closes a position. Use `OPEN` for a new position and `CLOSE` when closing an existing position."""
+
+    ratio_qty: Annotated[str, pydantic.Field(alias="ratioQty")]
+    r"""Leg ratio quantity as a decimal string. Use \"1\" for a standard one-to-one leg; use other ratios for spreads that require uneven leg sizing."""
+
+    security_type: Annotated[SecurityTypeEnum, pydantic.Field(alias="securityType")]
+    r"""What kind of instrument the order is for. Pick one:
+    - `CS` — Common Stock (equity / ETF).
+    - `OPT` — Option contract (call or put).
+    """
+
+    side: OrdLegSide
+    r"""Direction for this option leg. Use `BUY` when buying the leg and `SELL` when selling the leg."""
+
+    cfi_code: Annotated[Optional[str], pydantic.Field(alias="cfiCode")] = None
+    r"""Optional CFI code if your system uses ISO instrument classification. Most integrations can omit this unless their option workflow requires it."""
+
+    maturity: Optional[date] = None
+    r"""Option expiration date in YYYY-MM-DD format. Required for option legs when the contract is not fully identified elsewhere."""
+
+    put_call: Annotated[Optional[OrdLegPutCall], pydantic.Field(alias="putCall")] = None
+    r"""Option contract type. Use `CALL` for call options and `PUT` for put options."""
+
+    strike_price: Annotated[Optional[str], pydantic.Field(alias="strikePrice")] = None
+    r"""Option strike price as a decimal string. Required for option legs when the contract is not fully identified elsewhere."""
+
+    symbol: Optional[str] = None
+    r"""Underlying symbol for this option leg. Omit it when the leg uses the same underlying as the order-level symbol."""
+
+    @field_serializer("position_effect")
+    def serialize_position_effect(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrdLegPositionEffect(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("put_call")
+    def serialize_put_call(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrdLegPutCall(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("security_type")
+    def serialize_security_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SecurityTypeEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("side")
+    def serialize_side(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrdLegSide(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["cfiCode", "maturity", "putCall", "strikePrice", "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
+
+
+try:
+    OrdLeg.model_rebuild()
+except NameError:
+    pass

finance_dev/models/ordresponse.py

@@ -0,0 +1,202 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c77c5abfae10
+
+from __future__ import annotations
+from .ordersideenum import OrderSideEnum
+from datetime import datetime
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import field_serializer, model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OrdResponseStatus(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Current order lifecycle state, mirroring FIX Tag 39 (OrdStatus). Most common values you'll see:
+    - `PENDING_NEW` — broker has not yet acknowledged the order.
+    - `NEW` — order is live on the exchange (working, not yet executing).
+    - `PARTIALLY_FILLED` — some of `qty` has filled; check `cumQty` and `leavesQty`.
+    - `FILLED` — the entire order has executed.
+    - `PENDING_CANCEL` / `CANCELED` — cancel request in progress / completed.
+    - `PENDING_REPLACE` / `REPLACED` — replace request in progress / completed.
+    - `REJECTED` — broker refused the order; see `ordRejReason` and `text`.
+    - `EXPIRED` — order reached its time-in-force limit without filling.
+    - `STOPPED`, `SUSPENDED`, `DONE_FOR_DAY`, `CALCULATED`, `ACCEPTED_FOR_BID`, `SUPERSEDED` — additional FIX states; rare in normal flows.
+    """
+
+    NEW = "NEW"
+    PARTIALLY_FILLED = "PARTIALLY_FILLED"
+    FILLED = "FILLED"
+    DONE_FOR_DAY = "DONE_FOR_DAY"
+    CANCELED = "CANCELED"
+    REPLACED = "REPLACED"
+    PENDING_CANCEL = "PENDING_CANCEL"
+    STOPPED = "STOPPED"
+    REJECTED = "REJECTED"
+    SUSPENDED = "SUSPENDED"
+    PENDING_NEW = "PENDING_NEW"
+    CALCULATED = "CALCULATED"
+    EXPIRED = "EXPIRED"
+    ACCEPTED_FOR_BID = "ACCEPTED_FOR_BID"
+    PENDING_REPLACE = "PENDING_REPLACE"
+    SUPERSEDED = "SUPERSEDED"
+
+
+class OrdResponseTypedDict(TypedDict):
+    r"""Response returned after submitting an order request. Treat it as acknowledgement and continue monitoring order status until final fill, cancel, or rejection."""
+
+    avg_price: NotRequired[str]
+    r"""Average execution price for filled quantity. This is 0 until fills occur."""
+    cl_ord_id: NotRequired[str]
+    r"""Client order ID assigned to this order. Store this value to look up, replace, or cancel the order later."""
+    cum_qty: NotRequired[str]
+    r"""Quantity already filled. Compare this with qty to understand partial fills."""
+    leaves_qty: NotRequired[str]
+    r"""Quantity still open and eligible to fill. Value becomes 0 when the order is fully filled or no longer active."""
+    ord_rej_reason: NotRequired[str]
+    r"""Reason the order was rejected, when available. Use this to explain what the user needs to fix."""
+    qty: NotRequired[str]
+    r"""Original order quantity as a decimal string."""
+    side: NotRequired[OrderSideEnum]
+    r"""Which direction to trade in. Pick one:
+    - `BUY` — buying shares or contracts (opens a long position or closes an existing short).
+    - `SELL` — selling shares or contracts you already hold (closes a long position).
+    - `SELL_SHORT` — selling shares you do not own (opens a short position). Subject to short-sale regulations.
+    - `BUY_TO_COVER` — buying shares to close an open short position.
+    """
+    status: NotRequired[OrdResponseStatus]
+    r"""Current order lifecycle state, mirroring FIX Tag 39 (OrdStatus). Most common values you'll see:
+    - `PENDING_NEW` — broker has not yet acknowledged the order.
+    - `NEW` — order is live on the exchange (working, not yet executing).
+    - `PARTIALLY_FILLED` — some of `qty` has filled; check `cumQty` and `leavesQty`.
+    - `FILLED` — the entire order has executed.
+    - `PENDING_CANCEL` / `CANCELED` — cancel request in progress / completed.
+    - `PENDING_REPLACE` / `REPLACED` — replace request in progress / completed.
+    - `REJECTED` — broker refused the order; see `ordRejReason` and `text`.
+    - `EXPIRED` — order reached its time-in-force limit without filling.
+    - `STOPPED`, `SUSPENDED`, `DONE_FOR_DAY`, `CALCULATED`, `ACCEPTED_FOR_BID`, `SUPERSEDED` — additional FIX states; rare in normal flows.
+    """
+    success: NotRequired[bool]
+    r"""Whether the order request was accepted by Aries for processing. This does not guarantee a final fill."""
+    symbol: NotRequired[str]
+    r"""Symbol submitted on the order."""
+    text: NotRequired[str]
+    r"""Broker or system message. Show this to users when it explains a status or warning."""
+    transact_time: NotRequired[datetime]
+    r"""Time Aries or the broker recorded the order transaction."""
+
+
+class OrdResponse(BaseModel):
+    r"""Response returned after submitting an order request. Treat it as acknowledgement and continue monitoring order status until final fill, cancel, or rejection."""
+
+    avg_price: Annotated[Optional[str], pydantic.Field(alias="avgPrice")] = None
+    r"""Average execution price for filled quantity. This is 0 until fills occur."""
+
+    cl_ord_id: Annotated[Optional[str], pydantic.Field(alias="clOrdId")] = None
+    r"""Client order ID assigned to this order. Store this value to look up, replace, or cancel the order later."""
+
+    cum_qty: Annotated[Optional[str], pydantic.Field(alias="cumQty")] = None
+    r"""Quantity already filled. Compare this with qty to understand partial fills."""
+
+    leaves_qty: Annotated[Optional[str], pydantic.Field(alias="leavesQty")] = None
+    r"""Quantity still open and eligible to fill. Value becomes 0 when the order is fully filled or no longer active."""
+
+    ord_rej_reason: Annotated[Optional[str], pydantic.Field(alias="ordRejReason")] = (
+        None
+    )
+    r"""Reason the order was rejected, when available. Use this to explain what the user needs to fix."""
+
+    qty: Optional[str] = None
+    r"""Original order quantity as a decimal string."""
+
+    side: Optional[OrderSideEnum] = None
+    r"""Which direction to trade in. Pick one:
+    - `BUY` — buying shares or contracts (opens a long position or closes an existing short).
+    - `SELL` — selling shares or contracts you already hold (closes a long position).
+    - `SELL_SHORT` — selling shares you do not own (opens a short position). Subject to short-sale regulations.
+    - `BUY_TO_COVER` — buying shares to close an open short position.
+    """
+
+    status: Optional[OrdResponseStatus] = None
+    r"""Current order lifecycle state, mirroring FIX Tag 39 (OrdStatus). Most common values you'll see:
+    - `PENDING_NEW` — broker has not yet acknowledged the order.
+    - `NEW` — order is live on the exchange (working, not yet executing).
+    - `PARTIALLY_FILLED` — some of `qty` has filled; check `cumQty` and `leavesQty`.
+    - `FILLED` — the entire order has executed.
+    - `PENDING_CANCEL` / `CANCELED` — cancel request in progress / completed.
+    - `PENDING_REPLACE` / `REPLACED` — replace request in progress / completed.
+    - `REJECTED` — broker refused the order; see `ordRejReason` and `text`.
+    - `EXPIRED` — order reached its time-in-force limit without filling.
+    - `STOPPED`, `SUSPENDED`, `DONE_FOR_DAY`, `CALCULATED`, `ACCEPTED_FOR_BID`, `SUPERSEDED` — additional FIX states; rare in normal flows.
+    """
+
+    success: Optional[bool] = None
+    r"""Whether the order request was accepted by Aries for processing. This does not guarantee a final fill."""
+
+    symbol: Optional[str] = None
+    r"""Symbol submitted on the order."""
+
+    text: Optional[str] = None
+    r"""Broker or system message. Show this to users when it explains a status or warning."""
+
+    transact_time: Annotated[
+        Optional[datetime], pydantic.Field(alias="transactTime")
+    ] = None
+    r"""Time Aries or the broker recorded the order transaction."""
+
+    @field_serializer("side")
+    def serialize_side(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrderSideEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("status")
+    def serialize_status(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrdResponseStatus(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "avgPrice",
+                "clOrdId",
+                "cumQty",
+                "leavesQty",
+                "ordRejReason",
+                "qty",
+                "side",
+                "status",
+                "success",
+                "symbol",
+                "text",
+                "transactTime",
+            ]
+        )
+        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:
+    OrdResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/ownershipdataresponse.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 8b68203d0e8e
+
+from __future__ import annotations
+from .ownershiprecord import OwnershipRecord, OwnershipRecordTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class OwnershipDataResponseTypedDict(TypedDict):
+    r"""Response containing institutional ownership records."""
+
+    data: NotRequired[List[OwnershipRecordTypedDict]]
+    r"""List of institutional ownership records"""
+
+
+class OwnershipDataResponse(BaseModel):
+    r"""Response containing institutional ownership records."""
+
+    data: Optional[List[OwnershipRecord]] = None
+    r"""List of institutional ownership records"""
+
+    @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