compass_api_sdk 0.9.51__py3-none-any.whl → 0.9.52__py3-none-any.whl

compass_api_sdk/models/compass_api_backend_models_uniswap_transact_swap_request_buy_exactly_uniswapbuyexactlyrequest.py

@@ -0,0 +1,123 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .feeenum import FeeEnum
+from .token_enum import TokenEnum
+from compass_api_sdk.types import BaseModel
+from compass_api_sdk.utils import validate_const
+from enum import Enum
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenInTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenInTypedDict",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to swap from."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenIn = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenIn",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to swap from."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenOutTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenOutTypedDict",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to swap to."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenOut = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenOut",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to swap to."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestAmountOutTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestAmountOutTypedDict",
+    Union[float, str],
+)
+r"""The amount of 'token_out' to buy."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestAmountOut = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestAmountOut",
+    Union[float, str],
+)
+r"""The amount of 'token_out' to buy."""
+
+
+class CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTypedDict(
+    TypedDict
+):
+    r"""Request model for buying an exact amount of tokens."""
+
+    token_in: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenInTypedDict
+    r"""The symbol or address of the token to swap from."""
+    token_out: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenOutTypedDict
+    r"""The symbol or address of the token to swap to."""
+    fee: FeeEnum
+    r"""The transaction fee of a Uniswap pool in bips.
+
+    Uniswap supports 4 different fee levels.
+    """
+    amount_out: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestAmountOutTypedDict
+    r"""The amount of 'token_out' to buy."""
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
+    chain: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["UNISWAP_BUY_EXACTLY"]
+
+
+class CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequest(
+    BaseModel
+):
+    r"""Request model for buying an exact amount of tokens."""
+
+    token_in: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenIn
+    r"""The symbol or address of the token to swap from."""
+
+    token_out: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestTokenOut
+    r"""The symbol or address of the token to swap to."""
+
+    fee: FeeEnum
+    r"""The transaction fee of a Uniswap pool in bips.
+
+    Uniswap supports 4 different fee levels.
+    """
+
+    amount_out: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestAmountOut
+    r"""The amount of 'token_out' to buy."""
+
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
+
+    chain: CompassAPIBackendModelsUniswapTransactSwapRequestBuyExactlyUniswapBuyExactlyRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["UNISWAP_BUY_EXACTLY"]],
+            AfterValidator(validate_const("UNISWAP_BUY_EXACTLY")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "UNISWAP_BUY_EXACTLY"

compass_api_sdk/models/compass_api_backend_models_uniswap_transact_swap_request_sell_exactly_uniswapsellexactlyrequest.py

@@ -0,0 +1,123 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .feeenum import FeeEnum
+from .token_enum import TokenEnum
+from compass_api_sdk.types import BaseModel
+from compass_api_sdk.utils import validate_const
+from enum import Enum
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenInTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenInTypedDict",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to sell.."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenIn = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenIn",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to sell.."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenOutTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenOutTypedDict",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to buy.."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenOut = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenOut",
+    Union[TokenEnum, str],
+)
+r"""The symbol or address of the token to buy.."""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestAmountInTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestAmountInTypedDict",
+    Union[float, str],
+)
+r"""The amount of the `token_in` to sell"""
+
+
+CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestAmountIn = TypeAliasType(
+    "CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestAmountIn",
+    Union[float, str],
+)
+r"""The amount of the `token_in` to sell"""
+
+
+class CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTypedDict(
+    TypedDict
+):
+    r"""Request model for selling exactly an amount of tokens."""
+
+    token_in: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenInTypedDict
+    r"""The symbol or address of the token to sell.."""
+    token_out: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenOutTypedDict
+    r"""The symbol or address of the token to buy.."""
+    fee: FeeEnum
+    r"""The transaction fee of a Uniswap pool in bips.
+
+    Uniswap supports 4 different fee levels.
+    """
+    amount_in: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestAmountInTypedDict
+    r"""The amount of the `token_in` to sell"""
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
+    chain: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["UNISWAP_SELL_EXACTLY"]
+
+
+class CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequest(
+    BaseModel
+):
+    r"""Request model for selling exactly an amount of tokens."""
+
+    token_in: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenIn
+    r"""The symbol or address of the token to sell.."""
+
+    token_out: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestTokenOut
+    r"""The symbol or address of the token to buy.."""
+
+    fee: FeeEnum
+    r"""The transaction fee of a Uniswap pool in bips.
+
+    Uniswap supports 4 different fee levels.
+    """
+
+    amount_in: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestAmountIn
+    r"""The amount of the `token_in` to sell"""
+
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
+
+    chain: CompassAPIBackendModelsUniswapTransactSwapRequestSellExactlyUniswapSellExactlyRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["UNISWAP_SELL_EXACTLY"]],
+            AfterValidator(validate_const("UNISWAP_SELL_EXACTLY")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "UNISWAP_SELL_EXACTLY"

compass_api_sdk/models/{vaultgetvaultresponse.py → compass_api_backend_models_vaults_read_response_vault_vaultgetvaultresponse.py}

@@ -21,7 +21,9 @@ from pydantic import model_serializer
 from typing_extensions import NotRequired, TypedDict
 
 
-class VaultGetVaultResponseTypedDict(TypedDict):
+class CompassAPIBackendModelsVaultsReadResponseVaultVaultGetVaultResponseTypedDict(
+    TypedDict
+):
     name: str
     r"""Name of the vault."""
     symbol: str
@@ -42,7 +44,7 @@ class VaultGetVaultResponseTypedDict(TypedDict):
     r"""The user's position in the vault."""
 
 
-class VaultGetVaultResponse(BaseModel):
+class CompassAPIBackendModelsVaultsReadResponseVaultVaultGetVaultResponse(BaseModel):
     name: str
     r"""Name of the vault."""
 

compass_api_sdk/models/compass_api_backend_models_vaults_transact_request_deposit_vaultdepositrequest.py

@@ -0,0 +1,110 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from compass_api_sdk.utils import validate_const
+from enum import Enum
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestAmountTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestAmountTypedDict",
+    Union[float, str],
+)
+r"""The amount of tokens to deposit into the vault."""
+
+
+CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestAmount = (
+    TypeAliasType(
+        "CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestAmount",
+        Union[float, str],
+    )
+)
+r"""The amount of tokens to deposit into the vault."""
+
+
+class CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestTypedDict(
+    TypedDict
+):
+    vault_address: str
+    r"""The vault address you are depositing to."""
+    amount: CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestAmountTypedDict
+    r"""The amount of tokens to deposit into the vault."""
+    chain: CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["VAULT_DEPOSIT"]
+    receiver: NotRequired[Nullable[str]]
+    r"""The address which will receive the shares from the vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
+
+
+class CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequest(BaseModel):
+    vault_address: str
+    r"""The vault address you are depositing to."""
+
+    amount: CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestAmount
+    r"""The amount of tokens to deposit into the vault."""
+
+    chain: CompassAPIBackendModelsVaultsTransactRequestDepositVaultDepositRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["VAULT_DEPOSIT"]],
+            AfterValidator(validate_const("VAULT_DEPOSIT")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "VAULT_DEPOSIT"
+
+    receiver: OptionalNullable[str] = UNSET
+    r"""The address which will receive the shares from the vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["action_type", "receiver"]
+        nullable_fields = ["receiver"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

compass_api_sdk/models/compass_api_backend_models_vaults_transact_request_withdraw_vaultwithdrawrequest.py

@@ -0,0 +1,96 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from compass_api_sdk.utils import validate_const
+from enum import Enum
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from typing import Any, Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CompassAPIBackendModelsVaultsTransactRequestWithdrawVaultWithdrawRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class CompassAPIBackendModelsVaultsTransactRequestWithdrawVaultWithdrawRequestTypedDict(
+    TypedDict
+):
+    vault_address: str
+    r"""The vault address you are withdrawing from."""
+    amount: Any
+    r"""The amount of tokens to withdraw from the vault. If set to 'ALL', your total deposited token amount will be withdrawn."""
+    chain: CompassAPIBackendModelsVaultsTransactRequestWithdrawVaultWithdrawRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["VAULT_WITHDRAW"]
+    receiver: NotRequired[Nullable[str]]
+    r"""The address which will receive the tokens withdrawn. Defaults to the sender."""
+
+
+class CompassAPIBackendModelsVaultsTransactRequestWithdrawVaultWithdrawRequest(
+    BaseModel
+):
+    vault_address: str
+    r"""The vault address you are withdrawing from."""
+
+    amount: Any
+    r"""The amount of tokens to withdraw from the vault. If set to 'ALL', your total deposited token amount will be withdrawn."""
+
+    chain: CompassAPIBackendModelsVaultsTransactRequestWithdrawVaultWithdrawRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["VAULT_WITHDRAW"]],
+            AfterValidator(validate_const("VAULT_WITHDRAW")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "VAULT_WITHDRAW"
+
+    receiver: OptionalNullable[str] = UNSET
+    r"""The address which will receive the tokens withdrawn. Defaults to the sender."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["action_type", "receiver"]
+        nullable_fields = ["receiver"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

compass_api_sdk/models/details.py

@@ -3,9 +3,16 @@
 from __future__ import annotations
 from .movement10percent import Movement10Percent, Movement10PercentTypedDict
 from .yieldrange import YieldRange, YieldRangeTypedDict
-from compass_api_sdk.types import BaseModel
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
 import pydantic
-from typing_extensions import Annotated, TypedDict
+from pydantic import model_serializer
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class DetailsTypedDict(TypedDict):
@@ -13,10 +20,10 @@ class DetailsTypedDict(TypedDict):
     pendle_apy: float
     implied_apy: float
     fee_rate: float
-    movement10_percent: Movement10PercentTypedDict
     yield_range: YieldRangeTypedDict
     aggregated_apy: float
     max_boosted_apy: float
+    movement10_percent: NotRequired[Nullable[Movement10PercentTypedDict]]
 
 
 class Details(BaseModel):
@@ -28,12 +35,42 @@ class Details(BaseModel):
 
     fee_rate: Annotated[float, pydantic.Field(alias="feeRate")]
 
-    movement10_percent: Annotated[
-        Movement10Percent, pydantic.Field(alias="movement10Percent")
-    ]
-
     yield_range: Annotated[YieldRange, pydantic.Field(alias="yieldRange")]
 
     aggregated_apy: Annotated[float, pydantic.Field(alias="aggregatedApy")]
 
     max_boosted_apy: Annotated[float, pydantic.Field(alias="maxBoostedApy")]
+
+    movement10_percent: Annotated[
+        OptionalNullable[Movement10Percent], pydantic.Field(alias="movement10Percent")
+    ] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["movement10Percent"]
+        nullable_fields = ["movement10Percent"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

compass_api_sdk/models/movement10percent.py

@@ -1,23 +1,78 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from compass_api_sdk.types import BaseModel
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
 import pydantic
-from typing_extensions import Annotated, TypedDict
+from pydantic import model_serializer
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class Movement10PercentTypedDict(TypedDict):
-    pt_movement_up_usd: float
-    pt_movement_down_usd: float
-    yt_movement_up_usd: float
-    yt_movement_down_usd: float
+    pt_movement_up_usd: NotRequired[Nullable[float]]
+    pt_movement_down_usd: NotRequired[Nullable[float]]
+    yt_movement_up_usd: NotRequired[Nullable[float]]
+    yt_movement_down_usd: NotRequired[Nullable[float]]
 
 
 class Movement10Percent(BaseModel):
-    pt_movement_up_usd: Annotated[float, pydantic.Field(alias="ptMovementUpUsd")]
+    pt_movement_up_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ptMovementUpUsd")
+    ] = UNSET
 
-    pt_movement_down_usd: Annotated[float, pydantic.Field(alias="ptMovementDownUsd")]
+    pt_movement_down_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ptMovementDownUsd")
+    ] = UNSET
 
-    yt_movement_up_usd: Annotated[float, pydantic.Field(alias="ytMovementUpUsd")]
+    yt_movement_up_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ytMovementUpUsd")
+    ] = UNSET
 
-    yt_movement_down_usd: Annotated[float, pydantic.Field(alias="ytMovementDownUsd")]
+    yt_movement_down_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ytMovementDownUsd")
+    ] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "ptMovementUpUsd",
+            "ptMovementDownUsd",
+            "ytMovementUpUsd",
+            "ytMovementDownUsd",
+        ]
+        nullable_fields = [
+            "ptMovementUpUsd",
+            "ptMovementDownUsd",
+            "ytMovementUpUsd",
+            "ytMovementDownUsd",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m