finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/ownershiprecord.py

@@ -0,0 +1,74 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f16e7d1d496a
+
+from __future__ import annotations
+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 OwnershipRecordTypedDict(TypedDict):
+    r"""Ownership record of an institutional investor or fund in a security."""
+
+    change: NotRequired[int]
+    r"""Change in share count from previous filing"""
+    filing_date: NotRequired[str]
+    r"""Date of the regulatory filing in YYYY-MM-DD format"""
+    name: NotRequired[str]
+    r"""Name of the institutional investor or fund"""
+    percent_of_shares: NotRequired[float]
+    r"""Percentage of total outstanding shares held"""
+    share: NotRequired[int]
+    r"""Number of shares held"""
+    source: NotRequired[str]
+    r"""Source of the ownership data (e.g., 13F, 13G)"""
+
+
+class OwnershipRecord(BaseModel):
+    r"""Ownership record of an institutional investor or fund in a security."""
+
+    change: Optional[int] = None
+    r"""Change in share count from previous filing"""
+
+    filing_date: Annotated[Optional[str], pydantic.Field(alias="filingDate")] = None
+    r"""Date of the regulatory filing in YYYY-MM-DD format"""
+
+    name: Optional[str] = None
+    r"""Name of the institutional investor or fund"""
+
+    percent_of_shares: Annotated[
+        Optional[float], pydantic.Field(alias="percentOfShares")
+    ] = None
+    r"""Percentage of total outstanding shares held"""
+
+    share: Optional[int] = None
+    r"""Number of shares held"""
+
+    source: Optional[str] = None
+    r"""Source of the ownership data (e.g., 13F, 13G)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["change", "filingDate", "name", "percentOfShares", "share", "source"]
+        )
+        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:
+    OwnershipRecord.model_rebuild()
+except NameError:
+    pass

finance_dev/models/placeorderop.py

@@ -0,0 +1,40 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 386a2b651761
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .ordresponse import OrdResponse, OrdResponseTypedDict
+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 PlaceOrderResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    ord_response: NotRequired[OrdResponseTypedDict]
+    r"""Order placed successfully"""
+
+
+class PlaceOrderResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    ord_response: Optional[OrdResponse] = None
+    r"""Order placed successfully"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["OrdResponse"])
+        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/placeordrequest_union.py

@@ -0,0 +1,335 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 783019a66278
+
+from __future__ import annotations
+from .orderrequesttimeinforceenum import OrderRequestTimeInForceEnum
+from .ordersideenum import OrderSideEnum
+from .ordertypeenum import OrderTypeEnum
+from .ordleg import OrdLeg, OrdLegTypedDict
+from finance_dev import models
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import field_serializer, model_serializer
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class PlaceOrdRequest2TypedDict(TypedDict):
+    qty: str
+    r"""Number of shares or contracts to trade, sent as a decimal string. Example: \"10\" for ten shares or \"1\" for one option contract."""
+    side: 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.
+    """
+    symbol: str
+    r"""Ticker or underlying symbol to trade. Confirm the exact uppercase value with symbol search before placing an order."""
+    time_in_force: OrderRequestTimeInForceEnum
+    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.
+    """
+    trading_account_id: str
+    r"""Trading account identifier that should receive the order. Enter the tradingAccountId selected by the user."""
+    type: OrderTypeEnum
+    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`.
+    """
+    account_id: NotRequired[str]
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+    client_id: NotRequired[str]
+    r"""Optional identifier from your app. Send this when you want to tag orders by app, user, strategy, or integration for your own reconciliation."""
+    currency: NotRequired[str]
+    r"""Three-letter currency code for the order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+    legs: NotRequired[List[OrdLegTypedDict]]
+    r"""Option legs for single-leg or multi-leg option orders. Omit this field for equity orders. Send 1 leg for a single option contract or 2 to 4 legs for a spread or other multi-leg strategy."""
+    price: NotRequired[str]
+    r"""Limit price as a decimal string. Required for LIMIT and STOP_LIMIT orders. For buys, this is the maximum price you will pay; for sells, it is the minimum price you will accept."""
+    stop_price: NotRequired[str]
+    r"""Trigger price as a decimal string. Required for STOP and STOP_LIMIT orders. When the market reaches this price, the stop order becomes active."""
+
+
+class PlaceOrdRequest2(BaseModel):
+    qty: str
+    r"""Number of shares or contracts to trade, sent as a decimal string. Example: \"10\" for ten shares or \"1\" for one option contract."""
+
+    side: 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.
+    """
+
+    symbol: str
+    r"""Ticker or underlying symbol to trade. Confirm the exact uppercase value with symbol search before placing an order."""
+
+    time_in_force: Annotated[
+        OrderRequestTimeInForceEnum, pydantic.Field(alias="timeInForce")
+    ]
+    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.
+    """
+
+    trading_account_id: Annotated[str, pydantic.Field(alias="tradingAccountId")]
+    r"""Trading account identifier that should receive the order. Enter the tradingAccountId selected by the user."""
+
+    type: OrderTypeEnum
+    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`.
+    """
+
+    account_id: Annotated[Optional[str], pydantic.Field(alias="accountId")] = None
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""Optional identifier from your app. Send this when you want to tag orders by app, user, strategy, or integration for your own reconciliation."""
+
+    currency: Optional[str] = None
+    r"""Three-letter currency code for the order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+
+    legs: Optional[List[OrdLeg]] = None
+    r"""Option legs for single-leg or multi-leg option orders. Omit this field for equity orders. Send 1 leg for a single option contract or 2 to 4 legs for a spread or other multi-leg strategy."""
+
+    price: Optional[str] = None
+    r"""Limit price as a decimal string. Required for LIMIT and STOP_LIMIT orders. For buys, this is the maximum price you will pay; for sells, it is the minimum price you will accept."""
+
+    stop_price: Annotated[Optional[str], pydantic.Field(alias="stopPrice")] = None
+    r"""Trigger price as a decimal string. Required for STOP and STOP_LIMIT orders. When the market reaches this price, the stop order becomes active."""
+
+    @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("time_in_force")
+    def serialize_time_in_force(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrderRequestTimeInForceEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrderTypeEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["accountId", "clientId", "currency", "legs", "price", "stopPrice"]
+        )
+        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 PlaceOrdRequest1TypedDict(TypedDict):
+    account_id: str
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+    qty: str
+    r"""Number of shares or contracts to trade, sent as a decimal string. Example: \"10\" for ten shares or \"1\" for one option contract."""
+    side: 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.
+    """
+    symbol: str
+    r"""Ticker or underlying symbol to trade. Confirm the exact uppercase value with symbol search before placing an order."""
+    time_in_force: OrderRequestTimeInForceEnum
+    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.
+    """
+    type: OrderTypeEnum
+    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`.
+    """
+    client_id: NotRequired[str]
+    r"""Optional identifier from your app. Send this when you want to tag orders by app, user, strategy, or integration for your own reconciliation."""
+    currency: NotRequired[str]
+    r"""Three-letter currency code for the order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+    legs: NotRequired[List[OrdLegTypedDict]]
+    r"""Option legs for single-leg or multi-leg option orders. Omit this field for equity orders. Send 1 leg for a single option contract or 2 to 4 legs for a spread or other multi-leg strategy."""
+    price: NotRequired[str]
+    r"""Limit price as a decimal string. Required for LIMIT and STOP_LIMIT orders. For buys, this is the maximum price you will pay; for sells, it is the minimum price you will accept."""
+    stop_price: NotRequired[str]
+    r"""Trigger price as a decimal string. Required for STOP and STOP_LIMIT orders. When the market reaches this price, the stop order becomes active."""
+    trading_account_id: NotRequired[str]
+    r"""Trading account identifier that should receive the order. Enter the tradingAccountId selected by the user."""
+
+
+class PlaceOrdRequest1(BaseModel):
+    account_id: Annotated[str, pydantic.Field(alias="accountId")]
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+
+    qty: str
+    r"""Number of shares or contracts to trade, sent as a decimal string. Example: \"10\" for ten shares or \"1\" for one option contract."""
+
+    side: 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.
+    """
+
+    symbol: str
+    r"""Ticker or underlying symbol to trade. Confirm the exact uppercase value with symbol search before placing an order."""
+
+    time_in_force: Annotated[
+        OrderRequestTimeInForceEnum, pydantic.Field(alias="timeInForce")
+    ]
+    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.
+    """
+
+    type: OrderTypeEnum
+    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`.
+    """
+
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""Optional identifier from your app. Send this when you want to tag orders by app, user, strategy, or integration for your own reconciliation."""
+
+    currency: Optional[str] = None
+    r"""Three-letter currency code for the order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+
+    legs: Optional[List[OrdLeg]] = None
+    r"""Option legs for single-leg or multi-leg option orders. Omit this field for equity orders. Send 1 leg for a single option contract or 2 to 4 legs for a spread or other multi-leg strategy."""
+
+    price: Optional[str] = None
+    r"""Limit price as a decimal string. Required for LIMIT and STOP_LIMIT orders. For buys, this is the maximum price you will pay; for sells, it is the minimum price you will accept."""
+
+    stop_price: Annotated[Optional[str], pydantic.Field(alias="stopPrice")] = None
+    r"""Trigger price as a decimal string. Required for STOP and STOP_LIMIT orders. When the market reaches this price, the stop order becomes active."""
+
+    trading_account_id: Annotated[
+        Optional[str], pydantic.Field(alias="tradingAccountId")
+    ] = None
+    r"""Trading account identifier that should receive the order. Enter the tradingAccountId selected by the user."""
+
+    @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("time_in_force")
+    def serialize_time_in_force(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrderRequestTimeInForceEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OrderTypeEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["clientId", "currency", "legs", "price", "stopPrice", "tradingAccountId"]
+        )
+        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
+
+
+PlaceOrdRequestUnionTypedDict = TypeAliasType(
+    "PlaceOrdRequestUnionTypedDict",
+    Union[PlaceOrdRequest1TypedDict, PlaceOrdRequest2TypedDict],
+)
+r"""Request body for placing a live order through the core trading API. Use Preview Order first when available, then submit this only after the user confirms the trade."""
+
+
+PlaceOrdRequestUnion = TypeAliasType(
+    "PlaceOrdRequestUnion", Union[PlaceOrdRequest1, PlaceOrdRequest2]
+)
+r"""Request body for placing a live order through the core trading API. Use Preview Order first when available, then submit this only after the user confirms the trade."""
+
+
+try:
+    PlaceOrdRequest2.model_rebuild()
+except NameError:
+    pass
+try:
+    PlaceOrdRequest1.model_rebuild()
+except NameError:
+    pass

finance_dev/models/placepredictionorderop.py

@@ -0,0 +1,114 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c3714f3a8ed1
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .predordersorder import PredOrdersOrder, PredOrdersOrderTypedDict
+from .predordersplaceorderrequest import (
+    PredOrdersPlaceOrderRequest,
+    PredOrdersPlaceOrderRequestTypedDict,
+)
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, HeaderMetadata, RequestMetadata
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class PlacePredictionOrderRequestTypedDict(TypedDict):
+    pred_orders_place_order_request: PredOrdersPlaceOrderRequestTypedDict
+    idempotency_key: NotRequired[str]
+    r"""Makes a retry safe. A placement repeating a key you already used returns the order that key placed and places nothing new. The same key with different order terms returns `400` `INVALID_ORDER`. Without it, every request is a new order. Send it at most once."""
+
+
+class PlacePredictionOrderRequest(BaseModel):
+    pred_orders_place_order_request: Annotated[
+        PredOrdersPlaceOrderRequest,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="Idempotency-Key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""Makes a retry safe. A placement repeating a key you already used returns the order that key placed and places nothing new. The same key with different order terms returns `400` `INVALID_ORDER`. Without it, every request is a new order. Send it at most once."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["Idempotency-Key"])
+        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 PlacePredictionOrderResponseBodyTypedDict(TypedDict):
+    r"""Standard success envelope used by all success responses. `data` is endpoint-specific."""
+
+    success: bool
+    data: NotRequired[PredOrdersOrderTypedDict]
+    r"""An order as recorded by order entry. Submitted terms (`quantity`, `price`, …) never change; working terms (`workingQuantity`, `workingPrice`, …) are the venue's answer. Optional decimals and timestamps are omitted when absent, never zero."""
+
+
+class PlacePredictionOrderResponseBody(BaseModel):
+    r"""Standard success envelope used by all success responses. `data` is endpoint-specific."""
+
+    success: bool
+
+    data: Optional[PredOrdersOrder] = None
+    r"""An order as recorded by order entry. Submitted terms (`quantity`, `price`, …) never change; working terms (`workingQuantity`, `workingPrice`, …) are the venue's answer. Optional decimals and timestamps are omitted when absent, never zero."""
+
+    @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 PlacePredictionOrderResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    object: NotRequired[PlacePredictionOrderResponseBodyTypedDict]
+    r"""Order accepted for sending. `state` is normally `pending_new`."""
+
+
+class PlacePredictionOrderResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    object: Optional[PlacePredictionOrderResponseBody] = None
+    r"""Order accepted for sending. `state` is normally `pending_new`."""
+
+    @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

finance_dev/models/predmdbaseevent.py

@@ -0,0 +1,62 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: e6263eeafa39
+
+from __future__ import annotations
+from datetime import datetime
+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 PredMdBaseEventTypedDict(TypedDict):
+    r"""Top-level 4castex base event (e.g. UNR, HORC)."""
+
+    base_event_id: str
+    first_seen_at: datetime
+    last_synced_at: datetime
+    category_levels: NotRequired[List[str]]
+    r"""The venue's categories for this base event, broadest first: category, subcategory, then region. A few base events have fewer levels. Level names repeat under different parents, so identify a category by its whole path. Omitted until the venue's product listing has been synced for this base event."""
+    display_name: NotRequired[str]
+    r"""The venue's name for this base event. Omitted until the venue's product listing has been synced for this base event."""
+
+
+class PredMdBaseEvent(BaseModel):
+    r"""Top-level 4castex base event (e.g. UNR, HORC)."""
+
+    base_event_id: Annotated[str, pydantic.Field(alias="baseEventId")]
+
+    first_seen_at: Annotated[datetime, pydantic.Field(alias="firstSeenAt")]
+
+    last_synced_at: Annotated[datetime, pydantic.Field(alias="lastSyncedAt")]
+
+    category_levels: Annotated[
+        Optional[List[str]], pydantic.Field(alias="categoryLevels")
+    ] = None
+    r"""The venue's categories for this base event, broadest first: category, subcategory, then region. A few base events have fewer levels. Level names repeat under different parents, so identify a category by its whole path. Omitted until the venue's product listing has been synced for this base event."""
+
+    display_name: Annotated[Optional[str], pydantic.Field(alias="displayName")] = None
+    r"""The venue's name for this base event. Omitted until the venue's product listing has been synced for this base event."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["categoryLevels", "displayName"])
+        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:
+    PredMdBaseEvent.model_rebuild()
+except NameError:
+    pass