publicdotcom-cli 1.0.0__py3-none-any.whl

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response_open_close_indicator import (
+    ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseOpenCloseIndicator,
+)
+from ..models.com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response_side import (
+    ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseSide,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_order_instrument import (
+        ComHellopublicUserapigatewayApiRestOrderGatewayOrderInstrument,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details import (
+        ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails,
+    )
+
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse:
+    """# PreflightLegResponse
+    Response containing information about an individual leg in a multi-leg order preflight calculation.
+
+    ## Fields
+
+    ### Instrument Information
+    - **instrument** - The trading instrument for this leg
+    - **side** - The order side (BUY/SELL) for this leg
+    - **openCloseIndicator** - Position effect for option legs (BUY_TO_OPEN, BUY_TO_CLOSE, etc.)
+    - **ratioQuantity** - The ratio quantity for this leg in the strategy
+
+    ### Cost and Fee Information
+    - **estimatedCommission** - The estimated commission for this specific leg
+    - **estimatedCost** - The estimated cost for this leg including fees
+    - **estimatedProceeds** - The estimated proceeds for this leg (for sell legs)
+
+    ### Option-Specific Information
+    - **optionDetails** - Option-specific details like strike price, expiration, fees, and rebates
+
+        Attributes:
+            instrument (ComHellopublicUserapigatewayApiRestOrderGatewayOrderInstrument):
+            side (ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseSide):
+            ratio_quantity (int):
+            open_close_indicator (ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseOpenCloseIndicator |
+                Unset):
+            option_details (ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails | Unset):
+    """
+
+    instrument: ComHellopublicUserapigatewayApiRestOrderGatewayOrderInstrument
+    side: ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseSide
+    ratio_quantity: int
+    open_close_indicator: (
+        ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseOpenCloseIndicator | Unset
+    ) = UNSET
+    option_details: ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        instrument = self.instrument.to_dict()
+
+        side = self.side.value
+
+        ratio_quantity = self.ratio_quantity
+
+        open_close_indicator: str | Unset = UNSET
+        if not isinstance(self.open_close_indicator, Unset):
+            open_close_indicator = self.open_close_indicator.value
+
+        option_details: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.option_details, Unset):
+            option_details = self.option_details.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "instrument": instrument,
+                "side": side,
+                "ratioQuantity": ratio_quantity,
+            }
+        )
+        if open_close_indicator is not UNSET:
+            field_dict["openCloseIndicator"] = open_close_indicator
+        if option_details is not UNSET:
+            field_dict["optionDetails"] = option_details
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_order_instrument import (
+            ComHellopublicUserapigatewayApiRestOrderGatewayOrderInstrument,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details import (
+            ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails,
+        )
+
+        d = dict(src_dict)
+        instrument = ComHellopublicUserapigatewayApiRestOrderGatewayOrderInstrument.from_dict(
+            d.pop("instrument")
+        )
+
+        side = ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseSide(d.pop("side"))
+
+        ratio_quantity = d.pop("ratioQuantity")
+
+        _open_close_indicator = d.pop("openCloseIndicator", UNSET)
+        open_close_indicator: (
+            ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseOpenCloseIndicator
+            | Unset
+        )
+        if isinstance(_open_close_indicator, Unset):
+            open_close_indicator = UNSET
+        else:
+            open_close_indicator = (
+                ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseOpenCloseIndicator(
+                    _open_close_indicator
+                )
+            )
+
+        _option_details = d.pop("optionDetails", UNSET)
+        option_details: ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails | Unset
+        if isinstance(_option_details, Unset):
+            option_details = UNSET
+        else:
+            option_details = (
+                ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails.from_dict(
+                    _option_details
+                )
+            )
+
+        com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response = cls(
+            instrument=instrument,
+            side=side,
+            ratio_quantity=ratio_quantity,
+            open_close_indicator=open_close_indicator,
+            option_details=option_details,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response_open_close_indicator.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseOpenCloseIndicator(str, Enum):
+    CLOSE = "CLOSE"
+    OPEN = "OPEN"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response_side.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponseSide(str, Enum):
+    BUY = "BUY"
+    SELL = "SELL"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_request.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_request_order_type import (
+    ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequestOrderType,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_order_leg import (
+        ComHellopublicUserapigatewayApiRestOrderGatewayOrderLeg,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_order_order_expiration import (
+        ComHellopublicUserapigatewayApiRestOrderOrderExpiration,
+    )
+
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequest")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequest:
+    """# PreflightMultiLegRequest
+    Request for preflight calculations on multi-leg orders.
+
+    ## Fields
+    - **orderType** - The type of order (only LIMIT orders are allowed for multi-leg)
+    - **expiration** - The order expiration configuration
+    - **quantity** - The order quantity (number of strategies)
+    - **limitPrice** - The limit price for the order (required for LIMIT orders)
+    - **legs** - List of order legs (2-6 legs allowed, at most 1 equity leg)
+    - **equityMarketSession** - The market session for equity legs
+    - **validateOrder** - If true, the order will be validated against current account state. Defaults to true.
+
+        Attributes:
+            order_type (ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequestOrderType):
+            expiration (ComHellopublicUserapigatewayApiRestOrderOrderExpiration):
+            quantity (str):
+            limit_price (str):
+            legs (list[ComHellopublicUserapigatewayApiRestOrderGatewayOrderLeg]):
+            validate_order (bool | Unset):
+    """
+
+    order_type: ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequestOrderType
+    expiration: ComHellopublicUserapigatewayApiRestOrderOrderExpiration
+    quantity: str
+    limit_price: str
+    legs: list[ComHellopublicUserapigatewayApiRestOrderGatewayOrderLeg]
+    validate_order: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        order_type = self.order_type.value
+
+        expiration = self.expiration.to_dict()
+
+        quantity = self.quantity
+
+        limit_price = self.limit_price
+
+        legs = []
+        for legs_item_data in self.legs:
+            legs_item = legs_item_data.to_dict()
+            legs.append(legs_item)
+
+        validate_order = self.validate_order
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "orderType": order_type,
+                "expiration": expiration,
+                "quantity": quantity,
+                "limitPrice": limit_price,
+                "legs": legs,
+            }
+        )
+        if validate_order is not UNSET:
+            field_dict["validateOrder"] = validate_order
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_order_leg import (
+            ComHellopublicUserapigatewayApiRestOrderGatewayOrderLeg,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_order_order_expiration import (
+            ComHellopublicUserapigatewayApiRestOrderOrderExpiration,
+        )
+
+        d = dict(src_dict)
+        order_type = ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequestOrderType(
+            d.pop("orderType")
+        )
+
+        expiration = ComHellopublicUserapigatewayApiRestOrderOrderExpiration.from_dict(
+            d.pop("expiration")
+        )
+
+        quantity = d.pop("quantity")
+
+        limit_price = d.pop("limitPrice")
+
+        legs = []
+        _legs = d.pop("legs")
+        for legs_item_data in _legs:
+            legs_item = ComHellopublicUserapigatewayApiRestOrderGatewayOrderLeg.from_dict(
+                legs_item_data
+            )
+
+            legs.append(legs_item)
+
+        validate_order = d.pop("validateOrder", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_request = cls(
+            order_type=order_type,
+            expiration=expiration,
+            quantity=quantity,
+            limit_price=limit_price,
+            legs=legs,
+            validate_order=validate_order,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_request.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_request_order_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegRequestOrderType(str, Enum):
+    LIMIT = "LIMIT"
+    MARKET = "MARKET"
+    STOP = "STOP"
+    STOP_LIMIT = "STOP_LIMIT"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_response.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_impact import (
+        ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_requirement import (
+        ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_price_increment import (
+        ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_regulatory_fees import (
+        ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response import (
+        ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse,
+    )
+
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegResponse")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightPreflightMultiLegResponse:
+    """# PreflightMultiLegResponse
+    Response containing estimated costs, fees, and other information needed before placing a multi-leg order.
+
+    ## Fields
+
+    ### Strategy Information
+    - **baseSymbol** - The base symbol for the multi-leg strategy (e.g., "TSLA" for Tesla options)
+    - **strategyName** - The name of the strategy (e.g., "Call Spread", "Iron Condor")
+    - **legs** - List of individual leg details for the strategy
+
+    ### Cost and Fee Information
+    - **estimatedCommission** - The estimated commission amount that will be charged if the order executes
+    - **regulatoryFees** - Gateway regulatory fees breakdown including SEC, TAF, ORF, OCC, CAT fees
+    - **estimatedIndexOptionFee** - Estimated index option fees (if applicable)
+    - **estimatedCost** - The total estimated cost including all fees and commissions
+    - **buyingPowerRequirement** - The buying power required for this multi-leg order
+
+    ### Order Details
+    - **orderValue** - The estimated order value, excluding fees and commission
+    - **estimatedQuantity** - The number of strategies that will be executed
+    - **estimatedProceeds** - The estimated proceeds from the order (for credit spreads)
+
+    ### Option-Specific Information
+    - **marginRequirement** - Margin requirements for the multi-leg strategy
+    - **marginImpact** - Impact on account margin usage
+    - **priceIncrement** - Price increment information for option orders
+
+        Attributes:
+            base_symbol (str):
+            legs (list[ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse]):
+            order_value (str):
+            strategy_name (str | Unset):
+            estimated_commission (str | Unset):
+            regulatory_fees (ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees | Unset): #
+                GatewayRegulatoryFees
+                Represents various regulatory fees associated with trading orders.
+                <br/>
+                ## Fields
+                - **secFee** - The SEC charges a regulatory fee for sell orders that execute. The fee is based on the dollar
+                amount of the order.
+                - **tafFee** - The Trading Activity Fee is a FINRA fee. The fee is based on the order quantity.
+                - **orfFee** - The Options Regulatory Fee (ORF). This is the combined exchange fee rate for all exchanges.
+                Changes monthly.
+                - **exchangeFee** - The exchange charges a fee for executing orders for index options.
+                - **occFee** - The Options Clearing Corporation Fee (OCC)
+                - **catFee** - The Consolidated Audit Trail Fee (CAT)
+            estimated_index_option_fee (str | Unset):
+            estimated_quantity (str | Unset):
+            estimated_cost (str | Unset):
+            buying_power_requirement (str | Unset):
+            estimated_proceeds (str | Unset):
+            margin_requirement (ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement | Unset):
+            margin_impact (ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact | Unset):
+            price_increment (ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement | Unset): Price increment
+                information for option orders.
+    """
+
+    base_symbol: str
+    legs: list[ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse]
+    order_value: str
+    strategy_name: str | Unset = UNSET
+    estimated_commission: str | Unset = UNSET
+    regulatory_fees: ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees | Unset = (
+        UNSET
+    )
+    estimated_index_option_fee: str | Unset = UNSET
+    estimated_quantity: str | Unset = UNSET
+    estimated_cost: str | Unset = UNSET
+    buying_power_requirement: str | Unset = UNSET
+    estimated_proceeds: str | Unset = UNSET
+    margin_requirement: (
+        ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement | Unset
+    ) = UNSET
+    margin_impact: ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact | Unset = UNSET
+    price_increment: ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement | Unset = (
+        UNSET
+    )
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        base_symbol = self.base_symbol
+
+        legs = []
+        for legs_item_data in self.legs:
+            legs_item = legs_item_data.to_dict()
+            legs.append(legs_item)
+
+        order_value = self.order_value
+
+        strategy_name = self.strategy_name
+
+        estimated_commission = self.estimated_commission
+
+        regulatory_fees: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.regulatory_fees, Unset):
+            regulatory_fees = self.regulatory_fees.to_dict()
+
+        estimated_index_option_fee = self.estimated_index_option_fee
+
+        estimated_quantity = self.estimated_quantity
+
+        estimated_cost = self.estimated_cost
+
+        buying_power_requirement = self.buying_power_requirement
+
+        estimated_proceeds = self.estimated_proceeds
+
+        margin_requirement: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.margin_requirement, Unset):
+            margin_requirement = self.margin_requirement.to_dict()
+
+        margin_impact: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.margin_impact, Unset):
+            margin_impact = self.margin_impact.to_dict()
+
+        price_increment: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.price_increment, Unset):
+            price_increment = self.price_increment.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "baseSymbol": base_symbol,
+                "legs": legs,
+                "orderValue": order_value,
+            }
+        )
+        if strategy_name is not UNSET:
+            field_dict["strategyName"] = strategy_name
+        if estimated_commission is not UNSET:
+            field_dict["estimatedCommission"] = estimated_commission
+        if regulatory_fees is not UNSET:
+            field_dict["regulatoryFees"] = regulatory_fees
+        if estimated_index_option_fee is not UNSET:
+            field_dict["estimatedIndexOptionFee"] = estimated_index_option_fee
+        if estimated_quantity is not UNSET:
+            field_dict["estimatedQuantity"] = estimated_quantity
+        if estimated_cost is not UNSET:
+            field_dict["estimatedCost"] = estimated_cost
+        if buying_power_requirement is not UNSET:
+            field_dict["buyingPowerRequirement"] = buying_power_requirement
+        if estimated_proceeds is not UNSET:
+            field_dict["estimatedProceeds"] = estimated_proceeds
+        if margin_requirement is not UNSET:
+            field_dict["marginRequirement"] = margin_requirement
+        if margin_impact is not UNSET:
+            field_dict["marginImpact"] = margin_impact
+        if price_increment is not UNSET:
+            field_dict["priceIncrement"] = price_increment
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_impact import (
+            ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_requirement import (
+            ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_price_increment import (
+            ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_regulatory_fees import (
+            ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_preflight_preflight_leg_response import (
+            ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse,
+        )
+
+        d = dict(src_dict)
+        base_symbol = d.pop("baseSymbol")
+
+        legs = []
+        _legs = d.pop("legs")
+        for legs_item_data in _legs:
+            legs_item = ComHellopublicUserapigatewayApiRestPreflightPreflightLegResponse.from_dict(
+                legs_item_data
+            )
+
+            legs.append(legs_item)
+
+        order_value = d.pop("orderValue")
+
+        strategy_name = d.pop("strategyName", UNSET)
+
+        estimated_commission = d.pop("estimatedCommission", UNSET)
+
+        _regulatory_fees = d.pop("regulatoryFees", UNSET)
+        regulatory_fees: ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees | Unset
+        if isinstance(_regulatory_fees, Unset):
+            regulatory_fees = UNSET
+        else:
+            regulatory_fees = (
+                ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees.from_dict(
+                    _regulatory_fees
+                )
+            )
+
+        estimated_index_option_fee = d.pop("estimatedIndexOptionFee", UNSET)
+
+        estimated_quantity = d.pop("estimatedQuantity", UNSET)
+
+        estimated_cost = d.pop("estimatedCost", UNSET)
+
+        buying_power_requirement = d.pop("buyingPowerRequirement", UNSET)
+
+        estimated_proceeds = d.pop("estimatedProceeds", UNSET)
+
+        _margin_requirement = d.pop("marginRequirement", UNSET)
+        margin_requirement: (
+            ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement | Unset
+        )
+        if isinstance(_margin_requirement, Unset):
+            margin_requirement = UNSET
+        else:
+            margin_requirement = (
+                ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement.from_dict(
+                    _margin_requirement
+                )
+            )
+
+        _margin_impact = d.pop("marginImpact", UNSET)
+        margin_impact: ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact | Unset
+        if isinstance(_margin_impact, Unset):
+            margin_impact = UNSET
+        else:
+            margin_impact = (
+                ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact.from_dict(
+                    _margin_impact
+                )
+            )
+
+        _price_increment = d.pop("priceIncrement", UNSET)
+        price_increment: ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement | Unset
+        if isinstance(_price_increment, Unset):
+            price_increment = UNSET
+        else:
+            price_increment = (
+                ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement.from_dict(
+                    _price_increment
+                )
+            )
+
+        com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_response = cls(
+            base_symbol=base_symbol,
+            legs=legs,
+            order_value=order_value,
+            strategy_name=strategy_name,
+            estimated_commission=estimated_commission,
+            regulatory_fees=regulatory_fees,
+            estimated_index_option_fee=estimated_index_option_fee,
+            estimated_quantity=estimated_quantity,
+            estimated_cost=estimated_cost,
+            buying_power_requirement=buying_power_requirement,
+            estimated_proceeds=estimated_proceeds,
+            margin_requirement=margin_requirement,
+            margin_impact=margin_impact,
+            price_increment=price_increment,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_response.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_preflight_multi_leg_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties