compass_api_sdk 0.9.35__py3-none-any.whl → 2.0.21rc1__py3-none-any.whl

compass_api_sdk/models/uniswappoolpriceresponse.py

@@ -1,24 +1,15 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .token_enum import TokenEnum
 from compass_api_sdk.types import BaseModel
 from typing_extensions import TypedDict
 
 
 class UniswapPoolPriceResponseTypedDict(TypedDict):
-    token_in: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
-    token_out: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_in: str
+    r"""The first token in the pool"""
+    token_out: str
+    r"""The second token in the pool"""
     price: str
     r"""The price of the pool. This is expressed as an instantanteous amount of how many token0 you need to buy 1 token1. In any swap this will not change during the trade; use the quote endpoint to get a better idea of how much you will pay!"""
     tick: int
@@ -26,19 +17,11 @@ class UniswapPoolPriceResponseTypedDict(TypedDict):
 
 
 class UniswapPoolPriceResponse(BaseModel):
-    token_in: TokenEnum
-    r"""A class representing the token.
+    token_in: str
+    r"""The first token in the pool"""
 
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
-
-    token_out: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_out: str
+    r"""The second token in the pool"""
 
     price: str
     r"""The price of the pool. This is expressed as an instantanteous amount of how many token0 you need to buy 1 token1. In any swap this will not change during the trade; use the quote endpoint to get a better idea of how much you will pay!"""

compass_api_sdk/models/uniswappositionssolidityresponse.py

@@ -1,8 +1,15 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from compass_api_sdk.types import BaseModel
-from typing_extensions import TypedDict
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
 
 
 class UniswapPositionsSolidityResponseTypedDict(TypedDict):
@@ -18,6 +25,7 @@ class UniswapPositionsSolidityResponseTypedDict(TypedDict):
     fee_growth_inside1_last_x128: int
     tokens_owed0: int
     tokens_owed1: int
+    lp_token_address: NotRequired[Nullable[str]]
 
 
 class UniswapPositionsSolidityResponse(BaseModel):
@@ -44,3 +52,35 @@ class UniswapPositionsSolidityResponse(BaseModel):
     tokens_owed0: int
 
     tokens_owed1: int
+
+    lp_token_address: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["lp_token_address"]
+        nullable_fields = ["lp_token_address"]
+        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/uniswapsellexactlyparams.py

@@ -2,72 +2,53 @@
 
 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
 import pydantic
 from pydantic.functional_validators import AfterValidator
 from typing import Literal, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
-UniswapSellExactlyParamsAmountTypedDict = TypeAliasType(
-    "UniswapSellExactlyParamsAmountTypedDict", Union[float, str]
+UniswapSellExactlyParamsAmountInTypedDict = TypeAliasType(
+    "UniswapSellExactlyParamsAmountInTypedDict", Union[float, str]
 )
-r"""The amount of the token to swap from"""
+r"""The amount of the `token_in` to sell"""
 
 
-UniswapSellExactlyParamsAmount = TypeAliasType(
-    "UniswapSellExactlyParamsAmount", Union[float, str]
+UniswapSellExactlyParamsAmountIn = TypeAliasType(
+    "UniswapSellExactlyParamsAmountIn", Union[float, str]
 )
-r"""The amount of the token to swap from"""
+r"""The amount of the `token_in` to sell"""
 
 
 class UniswapSellExactlyParamsTypedDict(TypedDict):
     r"""Parameters model for selling exactly an amount of tokens."""
 
-    token_in: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
-    token_out: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_in: str
+    r"""The symbol or address of the token to sell.."""
+    token_out: str
+    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: UniswapSellExactlyParamsAmountTypedDict
-    r"""The amount of the token to swap from"""
+    amount_in: UniswapSellExactlyParamsAmountInTypedDict
+    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."""
     action_type: Literal["UNISWAP_SELL_EXACTLY"]
-    wrap_eth: NotRequired[bool]
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""
 
 
 class UniswapSellExactlyParams(BaseModel):
     r"""Parameters model for selling exactly an amount of tokens."""
 
-    token_in: TokenEnum
-    r"""A class representing the token.
+    token_in: str
+    r"""The symbol or address of the token to sell.."""
 
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
-
-    token_out: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_out: str
+    r"""The symbol or address of the token to buy.."""
 
     fee: FeeEnum
     r"""The transaction fee of a Uniswap pool in bips.
@@ -75,8 +56,8 @@ class UniswapSellExactlyParams(BaseModel):
     Uniswap supports 4 different fee levels.
     """
 
-    amount: UniswapSellExactlyParamsAmount
-    r"""The amount of the token to swap from"""
+    amount_in: UniswapSellExactlyParamsAmountIn
+    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."""
@@ -88,6 +69,3 @@ class UniswapSellExactlyParams(BaseModel):
         ],
         pydantic.Field(alias="action_type"),
     ] = "UNISWAP_SELL_EXACTLY"
-
-    wrap_eth: Optional[bool] = False
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""

compass_api_sdk/models/uniswapsellexactlyrequest.py

@@ -1,78 +1,66 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .chain import Chain
 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, NotRequired, TypeAliasType, TypedDict
 
 
-UniswapSellExactlyRequestAmountTypedDict = TypeAliasType(
-    "UniswapSellExactlyRequestAmountTypedDict", Union[float, str]
+UniswapSellExactlyRequestAmountInTypedDict = TypeAliasType(
+    "UniswapSellExactlyRequestAmountInTypedDict", Union[float, str]
 )
-r"""The amount of the token to swap from"""
+r"""The amount of the `token_in` to sell"""
 
 
-UniswapSellExactlyRequestAmount = TypeAliasType(
-    "UniswapSellExactlyRequestAmount", Union[float, str]
+UniswapSellExactlyRequestAmountIn = TypeAliasType(
+    "UniswapSellExactlyRequestAmountIn", Union[float, str]
 )
-r"""The amount of the token to swap from"""
+r"""The amount of the `token_in` to sell"""
 
 
-class UniswapSellExactlyRequestTypedDict(TypedDict):
-    r"""Request model for selling exactly an amount of tokens."""
+class UniswapSellExactlyRequestChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
-    token_in: TokenEnum
-    r"""A class representing the token.
 
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
-    token_out: TokenEnum
-    r"""A class representing the token.
+class UniswapSellExactlyRequestTypedDict(TypedDict):
+    r"""Request model for selling exactly an amount of tokens."""
 
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_in: str
+    r"""The symbol or address of the token to sell.."""
+    token_out: str
+    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: UniswapSellExactlyRequestAmountTypedDict
-    r"""The amount of the token to swap from"""
+    amount_in: UniswapSellExactlyRequestAmountInTypedDict
+    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: Chain
-    r"""The chain to use."""
+    chain: UniswapSellExactlyRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["UNISWAP_SELL_EXACTLY"]
-    wrap_eth: NotRequired[bool]
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
 
 
 class UniswapSellExactlyRequest(BaseModel):
     r"""Request model for selling exactly an amount of tokens."""
 
-    token_in: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_in: str
+    r"""The symbol or address of the token to sell.."""
 
-    token_out: TokenEnum
-    r"""A class representing the token.
-
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+    token_out: str
+    r"""The symbol or address of the token to buy.."""
 
     fee: FeeEnum
     r"""The transaction fee of a Uniswap pool in bips.
@@ -80,14 +68,13 @@ class UniswapSellExactlyRequest(BaseModel):
     Uniswap supports 4 different fee levels.
     """
 
-    amount: UniswapSellExactlyRequestAmount
-    r"""The amount of the token to swap from"""
+    amount_in: UniswapSellExactlyRequestAmountIn
+    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: Chain
-    r"""The chain to use."""
+    chain: UniswapSellExactlyRequestChain
 
     sender: str
     r"""The address of the transaction sender."""
@@ -100,5 +87,5 @@ class UniswapSellExactlyRequest(BaseModel):
         pydantic.Field(alias="action_type"),
     ] = "UNISWAP_SELL_EXACTLY"
 
-    wrap_eth: Optional[bool] = False
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""

compass_api_sdk/models/uniswapsellexactlytransactionresponse.py

@@ -0,0 +1,37 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .unsignedtransaction import UnsignedTransaction, UnsignedTransactionTypedDict
+from .useroperationresponse import UserOperationResponse, UserOperationResponseTypedDict
+from compass_api_sdk.types import BaseModel
+from typing import Union
+from typing_extensions import TypeAliasType, TypedDict
+
+
+UniswapSellExactlyTransactionResponseTransactionTypedDict = TypeAliasType(
+    "UniswapSellExactlyTransactionResponseTransactionTypedDict",
+    Union[UserOperationResponseTypedDict, UnsignedTransactionTypedDict],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+UniswapSellExactlyTransactionResponseTransaction = TypeAliasType(
+    "UniswapSellExactlyTransactionResponseTransaction",
+    Union[UserOperationResponse, UnsignedTransaction],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+class UniswapSellExactlyTransactionResponseTypedDict(TypedDict):
+    transaction: UniswapSellExactlyTransactionResponseTransactionTypedDict
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+    amount_out_quote: str
+    r"""The estimated amount out for the transaction. The actual output amount for this transaction is guaranteed be within the acceptable threshold, defined by the `max_slippage_percent`, relative to this quote."""
+
+
+class UniswapSellExactlyTransactionResponse(BaseModel):
+    transaction: UniswapSellExactlyTransactionResponseTransaction
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+    amount_out_quote: str
+    r"""The estimated amount out for the transaction. The actual output amount for this transaction is guaranteed be within the acceptable threshold, defined by the `max_slippage_percent`, relative to this quote."""

compass_api_sdk/models/uniswapwithdrawliquidityprovisionrequest.py

@@ -1,13 +1,13 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .chain import Chain
 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
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
 UniswapWithdrawLiquidityProvisionRequestPercentageForWithdrawalTypedDict = (
@@ -25,6 +25,12 @@ UniswapWithdrawLiquidityProvisionRequestPercentageForWithdrawal = TypeAliasType(
 r"""How much liquidity to take out in percentage."""
 
 
+class UniswapWithdrawLiquidityProvisionRequestChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
 class UniswapWithdrawLiquidityProvisionRequestTypedDict(TypedDict):
     token_id: int
     r"""Token ID of the NFT representing the liquidity provisioned position."""
@@ -32,11 +38,12 @@ class UniswapWithdrawLiquidityProvisionRequestTypedDict(TypedDict):
         UniswapWithdrawLiquidityProvisionRequestPercentageForWithdrawalTypedDict
     )
     r"""How much liquidity to take out in percentage."""
-    chain: Chain
-    r"""The chain to use."""
+    chain: UniswapWithdrawLiquidityProvisionRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["UNISWAP_WITHDRAW_LIQUIDITY_PROVISION"]
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
 
 
 class UniswapWithdrawLiquidityProvisionRequest(BaseModel):
@@ -48,8 +55,7 @@ class UniswapWithdrawLiquidityProvisionRequest(BaseModel):
     )
     r"""How much liquidity to take out in percentage."""
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: UniswapWithdrawLiquidityProvisionRequestChain
 
     sender: str
     r"""The address of the transaction sender."""
@@ -61,3 +67,6 @@ class UniswapWithdrawLiquidityProvisionRequest(BaseModel):
         ],
         pydantic.Field(alias="action_type"),
     ] = "UNISWAP_WITHDRAW_LIQUIDITY_PROVISION"
+
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""

compass_api_sdk/models/unsignedmulticalltransaction.py

@@ -2,37 +2,38 @@
 
 from __future__ import annotations
 from .signedauthorization import SignedAuthorization, SignedAuthorizationTypedDict
-from compass_api_sdk.types import BaseModel
+from compass_api_sdk.types import BaseModel, Nullable, UNSET_SENTINEL
 import pydantic
+from pydantic import model_serializer
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class UnsignedMulticallTransactionTypedDict(TypedDict):
-    chain_id: int
+    chain_id: str
     r"""The chain id of the transaction"""
     data: str
     r"""The data of the transaction"""
     from_: str
     r"""The sender of the transaction"""
-    gas: int
+    gas: Nullable[str]
     r"""The gas of the transaction"""
     to: str
     r"""The recipient of the transaction"""
-    value: int
+    value: str
     r"""The value of the transaction"""
-    nonce: int
+    nonce: str
     r"""The nonce of the address"""
-    max_fee_per_gas: int
+    max_fee_per_gas: str
     r"""The max fee per gas of the transaction"""
-    max_priority_fee_per_gas: int
+    max_priority_fee_per_gas: str
     r"""The max priority fee per gas of the transaction"""
     authorization_list: NotRequired[List[SignedAuthorizationTypedDict]]
     r"""EIP-7702 authorization"""
 
 
 class UnsignedMulticallTransaction(BaseModel):
-    chain_id: Annotated[int, pydantic.Field(alias="chainId")]
+    chain_id: Annotated[str, pydantic.Field(alias="chainId")]
     r"""The chain id of the transaction"""
 
     data: str
@@ -41,23 +42,23 @@ class UnsignedMulticallTransaction(BaseModel):
     from_: Annotated[str, pydantic.Field(alias="from")]
     r"""The sender of the transaction"""
 
-    gas: int
+    gas: Nullable[str]
     r"""The gas of the transaction"""
 
     to: str
     r"""The recipient of the transaction"""
 
-    value: int
+    value: str
     r"""The value of the transaction"""
 
-    nonce: int
+    nonce: str
     r"""The nonce of the address"""
 
-    max_fee_per_gas: Annotated[int, pydantic.Field(alias="maxFeePerGas")]
+    max_fee_per_gas: Annotated[str, pydantic.Field(alias="maxFeePerGas")]
     r"""The max fee per gas of the transaction"""
 
     max_priority_fee_per_gas: Annotated[
-        int, pydantic.Field(alias="maxPriorityFeePerGas")
+        str, pydantic.Field(alias="maxPriorityFeePerGas")
     ]
     r"""The max priority fee per gas of the transaction"""
 
@@ -65,3 +66,33 @@ class UnsignedMulticallTransaction(BaseModel):
         Optional[List[SignedAuthorization]], pydantic.Field(alias="authorizationList")
     ] = None
     r"""EIP-7702 authorization"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["authorizationList"]
+        nullable_fields = ["gas"]
+        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/unsignedtransaction.py

@@ -1,34 +1,35 @@
 """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, UNSET_SENTINEL
 import pydantic
+from pydantic import model_serializer
 from typing_extensions import Annotated, TypedDict
 
 
 class UnsignedTransactionTypedDict(TypedDict):
-    chain_id: int
+    chain_id: str
     r"""The chain id of the transaction"""
     data: str
     r"""The data of the transaction"""
     from_: str
     r"""The sender of the transaction"""
-    gas: int
+    gas: Nullable[str]
     r"""The gas of the transaction"""
     to: str
     r"""The recipient of the transaction"""
-    value: int
+    value: str
     r"""The value of the transaction"""
-    nonce: int
+    nonce: str
     r"""The nonce of the address"""
-    max_fee_per_gas: int
+    max_fee_per_gas: str
     r"""The max fee per gas of the transaction"""
-    max_priority_fee_per_gas: int
+    max_priority_fee_per_gas: str
     r"""The max priority fee per gas of the transaction"""
 
 
 class UnsignedTransaction(BaseModel):
-    chain_id: Annotated[int, pydantic.Field(alias="chainId")]
+    chain_id: Annotated[str, pydantic.Field(alias="chainId")]
     r"""The chain id of the transaction"""
 
     data: str
@@ -37,22 +38,52 @@ class UnsignedTransaction(BaseModel):
     from_: Annotated[str, pydantic.Field(alias="from")]
     r"""The sender of the transaction"""
 
-    gas: int
+    gas: Nullable[str]
     r"""The gas of the transaction"""
 
     to: str
     r"""The recipient of the transaction"""
 
-    value: int
+    value: str
     r"""The value of the transaction"""
 
-    nonce: int
+    nonce: str
     r"""The nonce of the address"""
 
-    max_fee_per_gas: Annotated[int, pydantic.Field(alias="maxFeePerGas")]
+    max_fee_per_gas: Annotated[str, pydantic.Field(alias="maxFeePerGas")]
     r"""The max fee per gas of the transaction"""
 
     max_priority_fee_per_gas: Annotated[
-        int, pydantic.Field(alias="maxPriorityFeePerGas")
+        str, pydantic.Field(alias="maxPriorityFeePerGas")
     ]
     r"""The max priority fee per gas of the transaction"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["gas"]
+        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