finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/replaceordrequest_union.py

@@ -0,0 +1,367 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c53ee292474c
+
+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 ReplaceOrdRequest2TypedDict(TypedDict):
+    orig_cl_ord_id: str
+    r"""Client order ID of the original open order you want to replace. Use the `clOrdId` returned by Place Order or List active orders. **Important — ID cycling:** each successful replace returns a new `clOrdId` in the response. For any subsequent replace of the same order, send this new `clOrdId` as `origClOrdId` — not the ID from the original placement. Reusing the old ID will be rejected."""
+    symbol: str
+    r"""Symbol on the original order. Use the exact symbol from the order record."""
+    trading_account_id: str
+    r"""Trading account identifier that owns the order being replaced. It must match the account on the original order."""
+    account_id: NotRequired[str]
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+    client_id: NotRequired[str]
+    r"""Optional new client identifier from your app for the replacement order. Use this when you need to track replacement attempts separately."""
+    currency: NotRequired[str]
+    r"""Three-letter currency code for the replacement order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+    legs: NotRequired[List[OrdLegTypedDict]]
+    r"""Option legs to replace, 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/multi-leg strategy. The instrument is identified from the legs (single leg) or auto-parsed from an OSI symbol when `legs` is omitted."""
+    price: NotRequired[str]
+    r"""Replacement limit price as a decimal string. Send it when changing a LIMIT or STOP_LIMIT order price."""
+    qty: NotRequired[str]
+    r"""Replacement order quantity as a decimal string. Send it when changing order size."""
+    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.
+    """
+    stop_price: NotRequired[str]
+    r"""Replacement stop trigger as a decimal string. Send it when changing a STOP or STOP_LIMIT order trigger."""
+    time_in_force: NotRequired[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: NotRequired[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`.
+    """
+
+
+class ReplaceOrdRequest2(BaseModel):
+    orig_cl_ord_id: Annotated[str, pydantic.Field(alias="origClOrdId")]
+    r"""Client order ID of the original open order you want to replace. Use the `clOrdId` returned by Place Order or List active orders. **Important — ID cycling:** each successful replace returns a new `clOrdId` in the response. For any subsequent replace of the same order, send this new `clOrdId` as `origClOrdId` — not the ID from the original placement. Reusing the old ID will be rejected."""
+
+    symbol: str
+    r"""Symbol on the original order. Use the exact symbol from the order record."""
+
+    trading_account_id: Annotated[str, pydantic.Field(alias="tradingAccountId")]
+    r"""Trading account identifier that owns the order being replaced. It must match the account on the original order."""
+
+    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 new client identifier from your app for the replacement order. Use this when you need to track replacement attempts separately."""
+
+    currency: Optional[str] = None
+    r"""Three-letter currency code for the replacement order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+
+    legs: Optional[List[OrdLeg]] = None
+    r"""Option legs to replace, 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/multi-leg strategy. The instrument is identified from the legs (single leg) or auto-parsed from an OSI symbol when `legs` is omitted."""
+
+    price: Optional[str] = None
+    r"""Replacement limit price as a decimal string. Send it when changing a LIMIT or STOP_LIMIT order price."""
+
+    qty: Optional[str] = None
+    r"""Replacement order quantity as a decimal string. Send it when changing order size."""
+
+    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.
+    """
+
+    stop_price: Annotated[Optional[str], pydantic.Field(alias="stopPrice")] = None
+    r"""Replacement stop trigger as a decimal string. Send it when changing a STOP or STOP_LIMIT order trigger."""
+
+    time_in_force: Annotated[
+        Optional[OrderRequestTimeInForceEnum], pydantic.Field(alias="timeInForce")
+    ] = None
+    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: Optional[OrderTypeEnum] = None
+    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`.
+    """
+
+    @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",
+                "qty",
+                "side",
+                "stopPrice",
+                "timeInForce",
+                "type",
+            ]
+        )
+        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 ReplaceOrdRequest1TypedDict(TypedDict):
+    account_id: str
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+    orig_cl_ord_id: str
+    r"""Client order ID of the original open order you want to replace. Use the `clOrdId` returned by Place Order or List active orders. **Important — ID cycling:** each successful replace returns a new `clOrdId` in the response. For any subsequent replace of the same order, send this new `clOrdId` as `origClOrdId` — not the ID from the original placement. Reusing the old ID will be rejected."""
+    symbol: str
+    r"""Symbol on the original order. Use the exact symbol from the order record."""
+    client_id: NotRequired[str]
+    r"""Optional new client identifier from your app for the replacement order. Use this when you need to track replacement attempts separately."""
+    currency: NotRequired[str]
+    r"""Three-letter currency code for the replacement order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+    legs: NotRequired[List[OrdLegTypedDict]]
+    r"""Option legs to replace, 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/multi-leg strategy. The instrument is identified from the legs (single leg) or auto-parsed from an OSI symbol when `legs` is omitted."""
+    price: NotRequired[str]
+    r"""Replacement limit price as a decimal string. Send it when changing a LIMIT or STOP_LIMIT order price."""
+    qty: NotRequired[str]
+    r"""Replacement order quantity as a decimal string. Send it when changing order size."""
+    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.
+    """
+    stop_price: NotRequired[str]
+    r"""Replacement stop trigger as a decimal string. Send it when changing a STOP or STOP_LIMIT order trigger."""
+    time_in_force: NotRequired[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: NotRequired[str]
+    r"""Trading account identifier that owns the order being replaced. It must match the account on the original order."""
+    type: NotRequired[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`.
+    """
+
+
+class ReplaceOrdRequest1(BaseModel):
+    account_id: Annotated[str, pydantic.Field(alias="accountId")]
+    r"""Account identifier; provide accountId or tradingAccountId. Both may be supplied."""
+
+    orig_cl_ord_id: Annotated[str, pydantic.Field(alias="origClOrdId")]
+    r"""Client order ID of the original open order you want to replace. Use the `clOrdId` returned by Place Order or List active orders. **Important — ID cycling:** each successful replace returns a new `clOrdId` in the response. For any subsequent replace of the same order, send this new `clOrdId` as `origClOrdId` — not the ID from the original placement. Reusing the old ID will be rejected."""
+
+    symbol: str
+    r"""Symbol on the original order. Use the exact symbol from the order record."""
+
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""Optional new client identifier from your app for the replacement order. Use this when you need to track replacement attempts separately."""
+
+    currency: Optional[str] = None
+    r"""Three-letter currency code for the replacement order. Use USD for U.S. dollar orders unless your integration supports another currency."""
+
+    legs: Optional[List[OrdLeg]] = None
+    r"""Option legs to replace, 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/multi-leg strategy. The instrument is identified from the legs (single leg) or auto-parsed from an OSI symbol when `legs` is omitted."""
+
+    price: Optional[str] = None
+    r"""Replacement limit price as a decimal string. Send it when changing a LIMIT or STOP_LIMIT order price."""
+
+    qty: Optional[str] = None
+    r"""Replacement order quantity as a decimal string. Send it when changing order size."""
+
+    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.
+    """
+
+    stop_price: Annotated[Optional[str], pydantic.Field(alias="stopPrice")] = None
+    r"""Replacement stop trigger as a decimal string. Send it when changing a STOP or STOP_LIMIT order trigger."""
+
+    time_in_force: Annotated[
+        Optional[OrderRequestTimeInForceEnum], pydantic.Field(alias="timeInForce")
+    ] = None
+    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[
+        Optional[str], pydantic.Field(alias="tradingAccountId")
+    ] = None
+    r"""Trading account identifier that owns the order being replaced. It must match the account on the original order."""
+
+    type: Optional[OrderTypeEnum] = None
+    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`.
+    """
+
+    @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",
+                "qty",
+                "side",
+                "stopPrice",
+                "timeInForce",
+                "tradingAccountId",
+                "type",
+            ]
+        )
+        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
+
+
+ReplaceOrdRequestUnionTypedDict = TypeAliasType(
+    "ReplaceOrdRequestUnionTypedDict",
+    Union[ReplaceOrdRequest1TypedDict, ReplaceOrdRequest2TypedDict],
+)
+r"""Request body for replacing an open order through the core trading API. Use this when the user changes price, quantity, stop price, or time-in-force before the order fully fills."""
+
+
+ReplaceOrdRequestUnion = TypeAliasType(
+    "ReplaceOrdRequestUnion", Union[ReplaceOrdRequest1, ReplaceOrdRequest2]
+)
+r"""Request body for replacing an open order through the core trading API. Use this when the user changes price, quantity, stop price, or time-in-force before the order fully fills."""
+
+
+try:
+    ReplaceOrdRequest2.model_rebuild()
+except NameError:
+    pass
+try:
+    ReplaceOrdRequest1.model_rebuild()
+except NameError:
+    pass

finance_dev/models/replaceordresponse.py

@@ -0,0 +1,144 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 751fea35b9b6
+
+from __future__ import annotations
+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 ReplaceOrdResponseStatus(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Order status after the replace request. Typical values after a successful replace:
+    - `PENDING_REPLACE` — replace request accepted by the broker but not yet final. Keep monitoring; will move to `REPLACED` once confirmed.
+    - `REPLACED` — the modification took effect. From now on, refer to the order by the new `clOrdId`.
+    - `REJECTED` — the replace was refused (e.g. the order had already fully filled). The original order is unchanged.
+
+    The full FIX OrdStatus enum is supported — see the Place Order response for the complete list of possible values.
+    """
+
+    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 ReplaceOrdResponseTypedDict(TypedDict):
+    r"""Response returned after requesting an order replacement. Treat it as the replacement result and monitor the new client order ID going forward."""
+
+    cl_ord_id: NotRequired[str]
+    r"""New client order ID assigned to the replacement order. Store this for future status, replace, or cancel operations."""
+    orig_cl_ord_id: NotRequired[str]
+    r"""Client order ID of the order that was replaced. Use it to connect the replacement back to the original order."""
+    price: NotRequired[str]
+    r"""Replacement order price as a decimal string. Display this as the current limit or reference price after a successful replace."""
+    qty: NotRequired[str]
+    r"""Replacement order quantity as a decimal string. Display this as the current order size after a successful replace."""
+    status: NotRequired[ReplaceOrdResponseStatus]
+    r"""Order status after the replace request. Typical values after a successful replace:
+    - `PENDING_REPLACE` — replace request accepted by the broker but not yet final. Keep monitoring; will move to `REPLACED` once confirmed.
+    - `REPLACED` — the modification took effect. From now on, refer to the order by the new `clOrdId`.
+    - `REJECTED` — the replace was refused (e.g. the order had already fully filled). The original order is unchanged.
+
+    The full FIX OrdStatus enum is supported — see the Place Order response for the complete list of possible values.
+    """
+    success: NotRequired[bool]
+    r"""Whether Aries or the broker accepted the replace request for processing."""
+    text: NotRequired[str]
+    r"""Broker or platform message about the replace result. Show it when replacement is rejected or pending."""
+    transact_time: NotRequired[datetime]
+    r"""Time the replace action was processed. Use it for order timelines and audit logs."""
+
+
+class ReplaceOrdResponse(BaseModel):
+    r"""Response returned after requesting an order replacement. Treat it as the replacement result and monitor the new client order ID going forward."""
+
+    cl_ord_id: Annotated[Optional[str], pydantic.Field(alias="clOrdId")] = None
+    r"""New client order ID assigned to the replacement order. Store this for future status, replace, or cancel operations."""
+
+    orig_cl_ord_id: Annotated[Optional[str], pydantic.Field(alias="origClOrdId")] = None
+    r"""Client order ID of the order that was replaced. Use it to connect the replacement back to the original order."""
+
+    price: Optional[str] = None
+    r"""Replacement order price as a decimal string. Display this as the current limit or reference price after a successful replace."""
+
+    qty: Optional[str] = None
+    r"""Replacement order quantity as a decimal string. Display this as the current order size after a successful replace."""
+
+    status: Optional[ReplaceOrdResponseStatus] = None
+    r"""Order status after the replace request. Typical values after a successful replace:
+    - `PENDING_REPLACE` — replace request accepted by the broker but not yet final. Keep monitoring; will move to `REPLACED` once confirmed.
+    - `REPLACED` — the modification took effect. From now on, refer to the order by the new `clOrdId`.
+    - `REJECTED` — the replace was refused (e.g. the order had already fully filled). The original order is unchanged.
+
+    The full FIX OrdStatus enum is supported — see the Place Order response for the complete list of possible values.
+    """
+
+    success: Optional[bool] = None
+    r"""Whether Aries or the broker accepted the replace request for processing."""
+
+    text: Optional[str] = None
+    r"""Broker or platform message about the replace result. Show it when replacement is rejected or pending."""
+
+    transact_time: Annotated[
+        Optional[datetime], pydantic.Field(alias="transactTime")
+    ] = None
+    r"""Time the replace action was processed. Use it for order timelines and audit logs."""
+
+    @field_serializer("status")
+    def serialize_status(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReplaceOrdResponseStatus(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "clOrdId",
+                "origClOrdId",
+                "price",
+                "qty",
+                "status",
+                "success",
+                "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:
+    ReplaceOrdResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/reportedbsitem.py

@@ -0,0 +1,53 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5c67c6833428
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ReportedBSItemTypedDict(TypedDict):
+    r"""Single balance sheet line item from a reported filing."""
+
+    concept: NotRequired[str]
+    r"""XBRL concept tag identifier for the financial line item"""
+    label: NotRequired[str]
+    r"""Human-readable label for the financial line item"""
+    unit: NotRequired[str]
+    r"""Unit of measurement (e.g., USD, shares)"""
+    value: NotRequired[float]
+    r"""Numerical value of the financial line item"""
+
+
+class ReportedBSItem(BaseModel):
+    r"""Single balance sheet line item from a reported filing."""
+
+    concept: Optional[str] = None
+    r"""XBRL concept tag identifier for the financial line item"""
+
+    label: Optional[str] = None
+    r"""Human-readable label for the financial line item"""
+
+    unit: Optional[str] = None
+    r"""Unit of measurement (e.g., USD, shares)"""
+
+    value: Optional[float] = None
+    r"""Numerical value of the financial line item"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["concept", "label", "unit", "value"])
+        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