circle-developer-controlled-wallets 6.2.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

circle/web3/developer_controlled_wallets/models/create_transfer_transaction_for_developer_response_data.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field, StrictStr
@@ -45,8 +50,10 @@ class CreateTransferTransactionForDeveloperResponseData(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> CreateTransferTransactionForDeveloperResponseData:

circle/web3/developer_controlled_wallets/models/create_wallet_request.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import List, Optional, Union
 from pydantic import BaseModel, Field, StrictBytes, StrictStr, conint, conlist
@@ -52,8 +57,10 @@ class CreateWalletRequest(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> CreateWalletRequest:

circle/web3/developer_controlled_wallets/models/create_wallet_set_request.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import Optional, Union
 from pydantic import BaseModel, Field, StrictBytes, StrictStr
@@ -45,8 +50,10 @@ class CreateWalletSetRequest(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> CreateWalletSetRequest:

circle/web3/developer_controlled_wallets/models/create_wallet_upgrade_transaction_for_developer.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field
@@ -44,8 +49,10 @@ class CreateWalletUpgradeTransactionForDeveloper(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> CreateWalletUpgradeTransactionForDeveloper:

circle/web3/developer_controlled_wallets/models/create_wallet_upgrade_transaction_for_developer_request.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import Optional, Union
 from pydantic import BaseModel, Field, StrictBytes, StrictStr
@@ -54,8 +59,10 @@ class CreateWalletUpgradeTransactionForDeveloperRequest(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> CreateWalletUpgradeTransactionForDeveloperRequest:

circle/web3/developer_controlled_wallets/models/derive_wallet_request.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import Optional
 from pydantic import BaseModel
@@ -44,8 +49,10 @@ class DeriveWalletRequest(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> DeriveWalletRequest:

circle/web3/developer_controlled_wallets/models/developer_wallet_set.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 from datetime import datetime
 
 from pydantic import BaseModel, Field, StrictStr, validator
@@ -53,8 +58,10 @@ class DeveloperWalletSet(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> DeveloperWalletSet:

circle/web3/developer_controlled_wallets/models/end_user_wallet_set.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 from datetime import datetime
 
 from pydantic import BaseModel, Field, StrictStr, constr, validator
@@ -54,8 +59,10 @@ class EndUserWalletSet(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EndUserWalletSet:

circle/web3/developer_controlled_wallets/models/eoa_wallet.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 from datetime import datetime
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr, constr, validator
@@ -36,7 +41,7 @@ class EOAWallet(BaseModel):
     user_id: Optional[constr(strict=True, max_length=50, min_length=5)] = Field(None, alias="userId", description="Unique system generated identifier for the user.")
     wallet_set_id: StrictStr = Field(..., alias="walletSetId", description="System-generated unique identifier of the resource.")
     initial_public_key: Optional[StrictStr] = Field(None, alias="initialPublicKey", description="For NEAR blockchains only, the originally assigned public key of a wallet at the time of its creation.")
-    account_type: StrictStr = Field(..., alias="accountType", description="An account can be a Smart Contract Account (SCA) or an Externally Owned Account (EOA). To learn more, see the [account types guide](https://developers.circle.com/w3s/docs/programmable-wallets-account-types).  If an account type is not specified during the creation of a wallet, it defaults to `EOA` (Externally Owned Account). Note that Solana doesn't support Smart Contract Account (SCA). ")
+    account_type: StrictStr = Field(..., alias="accountType", description="An account can be a Smart Contract Account (SCA) or an Externally Owned Account (EOA). To learn more, see the [account types guide](https://developers.circle.com/w3s/docs/programmable-wallets-account-types).  If an account type is not specified during the creation of a wallet, it defaults to `EOA` (Externally Owned Account). Note that Solana and Aptos don't support Smart Contract Account (SCA). ")
     __properties = ["id", "address", "blockchain", "createDate", "updateDate", "custodyType", "name", "refId", "state", "userId", "walletSetId", "initialPublicKey", "accountType"]
 
     def __init__(self, **kwargs):
@@ -65,8 +70,10 @@ class EOAWallet(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EOAWallet:

circle/web3/developer_controlled_wallets/models/eoa_wallet_with_balances.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 from datetime import datetime
 from typing import List, Optional
 from pydantic import BaseModel, Field, StrictStr, conlist, constr, validator
@@ -37,7 +42,7 @@ class EOAWalletWithBalances(BaseModel):
     user_id: Optional[constr(strict=True, max_length=50, min_length=5)] = Field(None, alias="userId", description="Unique system generated identifier for the user.")
     wallet_set_id: StrictStr = Field(..., alias="walletSetId", description="System-generated unique identifier of the resource.")
     initial_public_key: Optional[StrictStr] = Field(None, alias="initialPublicKey", description="For NEAR blockchains only, the originally assigned public key of a wallet at the time of its creation.")
-    account_type: StrictStr = Field(..., alias="accountType", description="An account can be a Smart Contract Account (SCA) or an Externally Owned Account (EOA). To learn more, see the [account types guide](https://developers.circle.com/w3s/docs/programmable-wallets-account-types).  If an account type is not specified during the creation of a wallet, it defaults to `EOA` (Externally Owned Account). Note that Solana doesn't support Smart Contract Account (SCA). ")
+    account_type: StrictStr = Field(..., alias="accountType", description="An account can be a Smart Contract Account (SCA) or an Externally Owned Account (EOA). To learn more, see the [account types guide](https://developers.circle.com/w3s/docs/programmable-wallets-account-types).  If an account type is not specified during the creation of a wallet, it defaults to `EOA` (Externally Owned Account). Note that Solana and Aptos don't support Smart Contract Account (SCA). ")
     token_balances: conlist(Balance) = Field(..., alias="tokenBalances", description="Lists native token balances and, if specified, USDC/EURC balances for the wallets.")
     __properties = ["id", "address", "blockchain", "createDate", "updateDate", "custodyType", "name", "refId", "state", "userId", "walletSetId", "initialPublicKey", "accountType", "tokenBalances"]
 
@@ -67,8 +72,10 @@ class EOAWalletWithBalances(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EOAWalletWithBalances:

circle/web3/developer_controlled_wallets/models/error.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field, StrictInt, StrictStr
@@ -44,8 +49,10 @@ class Error(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> Error:

circle/web3/developer_controlled_wallets/models/estimate_contract_execution_transaction_fee_request.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import List, Optional
 from pydantic import BaseModel, Field, StrictStr, conlist
@@ -52,8 +57,10 @@ class EstimateContractExecutionTransactionFeeRequest(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EstimateContractExecutionTransactionFeeRequest:

circle/web3/developer_controlled_wallets/models/estimate_transaction_fee.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field
@@ -44,8 +49,10 @@ class EstimateTransactionFee(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EstimateTransactionFee:

circle/web3/developer_controlled_wallets/models/estimate_transaction_fee_data.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr
@@ -49,8 +54,10 @@ class EstimateTransactionFeeData(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EstimateTransactionFeeData:

circle/web3/developer_controlled_wallets/models/estimate_transfer_transaction_fee_request.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import List, Optional
 from pydantic import BaseModel, Field, StrictStr, conlist
@@ -51,8 +56,10 @@ class EstimateTransferTransactionFeeRequest(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> EstimateTransferTransactionFeeRequest:

circle/web3/developer_controlled_wallets/models/evm_blockchain.py

@@ -39,6 +39,8 @@ class EvmBlockchain(str, Enum):
     BASE_MINUS_SEPOLIA = 'BASE-SEPOLIA'
     OP = 'OP'
     OP_MINUS_SEPOLIA = 'OP-SEPOLIA'
+    EVM = 'EVM'
+    EVM_MINUS_TESTNET = 'EVM-TESTNET'
 
     @classmethod
     def from_json(cls, json_str: str) -> EvmBlockchain:

circle/web3/developer_controlled_wallets/models/nft.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 from datetime import datetime
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr
@@ -48,8 +53,10 @@ class Nft(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> Nft:

circle/web3/developer_controlled_wallets/models/nfts.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field
@@ -44,8 +49,10 @@ class Nfts(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> Nfts:

circle/web3/developer_controlled_wallets/models/nfts_data.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import List, Optional
 from pydantic import BaseModel, conlist
@@ -44,8 +49,10 @@ class NftsData(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> NftsData:

circle/web3/developer_controlled_wallets/models/not_authorized_response.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field, StrictInt, StrictStr
@@ -44,8 +49,10 @@ class NotAuthorizedResponse(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> NotAuthorizedResponse:

circle/web3/developer_controlled_wallets/models/not_found_response.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 
 from pydantic import BaseModel, Field, StrictInt, StrictStr
@@ -44,8 +49,10 @@ class NotFoundResponse(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> NotFoundResponse:

circle/web3/developer_controlled_wallets/models/risk_signal.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 
 from typing import List
 from pydantic import BaseModel, Field, StrictStr, conlist, validator
@@ -57,8 +62,10 @@ class RiskSignal(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> RiskSignal:

circle/web3/developer_controlled_wallets/models/sca_wallet.py

@@ -13,6 +13,11 @@ import pprint
 import re  # noqa: F401
 import json
 
+# CUSTOMIZED: Added pydantic_encoder import (not in default OpenAPI Generator template)
+# pydantic_encoder is needed to address serialization issues with datetime and other non-primitive fields,
+# which are not handled by the default JSON encoder.
+from pydantic.json import pydantic_encoder
+
 from datetime import datetime
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr, constr, validator
@@ -37,7 +42,7 @@ class SCAWallet(BaseModel):
     user_id: Optional[constr(strict=True, max_length=50, min_length=5)] = Field(None, alias="userId", description="Unique system generated identifier for the user.")
     wallet_set_id: StrictStr = Field(..., alias="walletSetId", description="System-generated unique identifier of the resource.")
     initial_public_key: Optional[StrictStr] = Field(None, alias="initialPublicKey", description="For NEAR blockchains only, the originally assigned public key of a wallet at the time of its creation.")
-    account_type: StrictStr = Field(..., alias="accountType", description="An account can be a Smart Contract Account (SCA) or an Externally Owned Account (EOA). To learn more, see the [account types guide](https://developers.circle.com/w3s/docs/programmable-wallets-account-types).  If an account type is not specified during the creation of a wallet, it defaults to `EOA` (Externally Owned Account). Note that Solana doesn't support Smart Contract Account (SCA). ")
+    account_type: StrictStr = Field(..., alias="accountType", description="An account can be a Smart Contract Account (SCA) or an Externally Owned Account (EOA). To learn more, see the [account types guide](https://developers.circle.com/w3s/docs/programmable-wallets-account-types).  If an account type is not specified during the creation of a wallet, it defaults to `EOA` (Externally Owned Account). Note that Solana and Aptos don't support Smart Contract Account (SCA). ")
     sca_core: ScaCore = Field(..., alias="scaCore")
     __properties = ["id", "address", "blockchain", "createDate", "updateDate", "custodyType", "name", "refId", "state", "userId", "walletSetId", "initialPublicKey", "accountType", "scaCore"]
 
@@ -67,8 +72,10 @@ class SCAWallet(BaseModel):
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        """Return JSON string of the model (handles datetime/UUID/Decimal/Enum, etc.)"""
+        # CUSTOMIZED: Added default=pydantic_encoder to handle complex types (datetime, UUID, Enum, etc.)
+        # This differs from the default OpenAPI Generator template which doesn't handle these types properly
+        return json.dumps(self.to_dict(), default=pydantic_encoder)
 
     @classmethod
     def from_json(cls, json_str: str) -> SCAWallet: