circle-developer-controlled-wallets 0.1.0b1__py3-none-any.whl → 1.1.0__py3-none-any.whl

circle/web3/developer_controlled_wallets/api/wallets_api.py

@@ -22,14 +22,13 @@ from pydantic import Field, StrictBool, StrictStr, conint
 
 from typing import Optional
 
-from circle.web3.developer_controlled_wallets.models.create_developer_wallet200_response import CreateDeveloperWallet200Response
-from circle.web3.developer_controlled_wallets.models.create_developer_wallet_request import CreateDeveloperWalletRequest
-from circle.web3.developer_controlled_wallets.models.ext_update_wallet_metadata_request import ExtUpdateWalletMetadataRequest
-from circle.web3.developer_controlled_wallets.models.get_wallet200_response import GetWallet200Response
+from circle.web3.developer_controlled_wallets.models.blockchain import Blockchain
+from circle.web3.developer_controlled_wallets.models.create_wallet_request import CreateWalletRequest
 from circle.web3.developer_controlled_wallets.models.list_wallet_ballance200_response import ListWalletBallance200Response
 from circle.web3.developer_controlled_wallets.models.list_wallet_nfts200_response import ListWalletNfts200Response
-from circle.web3.developer_controlled_wallets.models.list_wallets200_response import ListWallets200Response
-from circle.web3.developer_controlled_wallets.models.update_wallet200_response import UpdateWallet200Response
+from circle.web3.developer_controlled_wallets.models.update_wallet_request import UpdateWalletRequest
+from circle.web3.developer_controlled_wallets.models.wallet2 import Wallet2
+from circle.web3.developer_controlled_wallets.models.wallets import Wallets
 
 from circle.web3.developer_controlled_wallets.api_client import ApiClient
 from circle.web3.developer_controlled_wallets.api_response import ApiResponse
@@ -69,18 +68,20 @@ class WalletsApi(object):
 
     @auto_fill
     @validate_arguments
-    def create_developer_wallet(self, create_developer_wallet_request : Annotated[CreateDeveloperWalletRequest, Field(..., description="Wallets creation request")], **kwargs) -> CreateDeveloperWallet200Response:  # noqa: E501
+    def create_wallet(self, create_wallet_request : Annotated[CreateWalletRequest, Field(..., description="Schema for the request payload to create a new wallet.")], x_request_id : Annotated[Optional[StrictStr], Field(description="Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.")] = None, **kwargs) -> Wallets:  # noqa: E501
         """Create wallets  # noqa: E501
 
         Generates a new developer-controlled wallet or batch of wallets within a wallet set, specifying blockchain and wallet name.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.create_developer_wallet(create_developer_wallet_request, async_req=True)
+        >>> thread = api.create_wallet(create_wallet_request, x_request_id, async_req=True)
         >>> result = thread.get()
 
-        :param create_developer_wallet_request: Wallets creation request (required)
-        :type create_developer_wallet_request: CreateDeveloperWalletRequest
+        :param create_wallet_request: Schema for the request payload to create a new wallet. (required)
+        :type create_wallet_request: CreateWalletRequest
+        :param x_request_id: Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.
+        :type x_request_id: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: timeout setting for this request. If one
@@ -90,27 +91,29 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: CreateDeveloperWallet200Response
+        :rtype: Wallets
         """
         kwargs['_return_http_data_only'] = True
         if '_preload_content' in kwargs:
-            raise ValueError("Error! Please call the create_developer_wallet_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
-        return self.create_developer_wallet_with_http_info(create_developer_wallet_request, **kwargs)  # noqa: E501
+            raise ValueError("Error! Please call the create_wallet_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
+        return self.create_wallet_with_http_info(create_wallet_request, x_request_id, **kwargs)  # noqa: E501
 
     @auto_fill
     @validate_arguments
-    def create_developer_wallet_with_http_info(self, create_developer_wallet_request : Annotated[CreateDeveloperWalletRequest, Field(..., description="Wallets creation request")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_wallet_with_http_info(self, create_wallet_request : Annotated[CreateWalletRequest, Field(..., description="Schema for the request payload to create a new wallet.")], x_request_id : Annotated[Optional[StrictStr], Field(description="Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """Create wallets  # noqa: E501
 
         Generates a new developer-controlled wallet or batch of wallets within a wallet set, specifying blockchain and wallet name.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.create_developer_wallet_with_http_info(create_developer_wallet_request, async_req=True)
+        >>> thread = api.create_wallet_with_http_info(create_wallet_request, x_request_id, async_req=True)
         >>> result = thread.get()
 
-        :param create_developer_wallet_request: Wallets creation request (required)
-        :type create_developer_wallet_request: CreateDeveloperWalletRequest
+        :param create_wallet_request: Schema for the request payload to create a new wallet. (required)
+        :type create_wallet_request: CreateWalletRequest
+        :param x_request_id: Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.
+        :type x_request_id: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -133,13 +136,14 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(CreateDeveloperWallet200Response, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(Wallets, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
         _all_params = [
-            'create_developer_wallet_request'
+            'create_wallet_request',
+            'x_request_id'
         ]
         _all_params.extend(
             [
@@ -158,7 +162,7 @@ class WalletsApi(object):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_developer_wallet" % _key
+                    " to method create_wallet" % _key
                 )
             _params[_key] = _val
         del _params['kwargs']
@@ -172,13 +176,16 @@ class WalletsApi(object):
         _query_params = []
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
+        if _params['x_request_id']:
+            _header_params['X-Request-Id'] = _params['x_request_id']
+
         # process the form parameters
         _form_params = []
         _files = {}
         # process the body parameter
         _body_params = None
-        if _params['create_developer_wallet_request'] is not None:
-            _body_params = _params['create_developer_wallet_request']
+        if _params['create_wallet_request'] is not None:
+            _body_params = _params['create_wallet_request']
 
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(
@@ -195,11 +202,13 @@ class WalletsApi(object):
         _auth_settings = ['BearerAuth']  # noqa: E501
 
         _response_types_map = {
-            '200': "CreateDeveloperWallet200Response",
+            '200': "Wallets",
+            '400': "BadRequestResponse",
+            '401': "NotAuthorizedResponse",
         }
 
         return self.api_client.call_api(
-            '/developer/wallets', 'POST',
+            '/v1/w3s/developer/wallets', 'POST',
             _path_params,
             _query_params,
             _header_params,
@@ -217,18 +226,20 @@ class WalletsApi(object):
 
     @auto_fill
     @validate_arguments
-    def get_wallet(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], **kwargs) -> GetWallet200Response:  # noqa: E501
-        """Get a wallet  # noqa: E501
+    def get_wallet(self, id : Annotated[StrictStr, Field(..., description="The universally unique identifier (UUID v4) of the resource.")], x_request_id : Annotated[Optional[StrictStr], Field(description="Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.")] = None, **kwargs) -> Wallet2:  # noqa: E501
+        """Retrieve a wallet  # noqa: E501
 
-        Retrieves info for a single developer-controlled wallet using it's unique identifier.  # noqa: E501
+        Retrieve an existing wallet  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_wallet(id, async_req=True)
+        >>> thread = api.get_wallet(id, x_request_id, async_req=True)
         >>> result = thread.get()
 
-        :param id: Wallet ID (required)
+        :param id: The universally unique identifier (UUID v4) of the resource. (required)
         :type id: str
+        :param x_request_id: Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.
+        :type x_request_id: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: timeout setting for this request. If one
@@ -238,27 +249,29 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: GetWallet200Response
+        :rtype: Wallet2
         """
         kwargs['_return_http_data_only'] = True
         if '_preload_content' in kwargs:
             raise ValueError("Error! Please call the get_wallet_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
-        return self.get_wallet_with_http_info(id, **kwargs)  # noqa: E501
+        return self.get_wallet_with_http_info(id, x_request_id, **kwargs)  # noqa: E501
 
     @auto_fill
     @validate_arguments
-    def get_wallet_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], **kwargs) -> ApiResponse:  # noqa: E501
-        """Get a wallet  # noqa: E501
+    def get_wallet_with_http_info(self, id : Annotated[StrictStr, Field(..., description="The universally unique identifier (UUID v4) of the resource.")], x_request_id : Annotated[Optional[StrictStr], Field(description="Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """Retrieve a wallet  # noqa: E501
 
-        Retrieves info for a single developer-controlled wallet using it's unique identifier.  # noqa: E501
+        Retrieve an existing wallet  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_wallet_with_http_info(id, async_req=True)
+        >>> thread = api.get_wallet_with_http_info(id, x_request_id, async_req=True)
         >>> result = thread.get()
 
-        :param id: Wallet ID (required)
+        :param id: The universally unique identifier (UUID v4) of the resource. (required)
         :type id: str
+        :param x_request_id: Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.
+        :type x_request_id: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -281,13 +294,14 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(GetWallet200Response, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(Wallet2, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
         _all_params = [
-            'id'
+            'id',
+            'x_request_id'
         ]
         _all_params.extend(
             [
@@ -323,6 +337,9 @@ class WalletsApi(object):
         _query_params = []
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
+        if _params['x_request_id']:
+            _header_params['X-Request-Id'] = _params['x_request_id']
+
         # process the form parameters
         _form_params = []
         _files = {}
@@ -336,11 +353,13 @@ class WalletsApi(object):
         _auth_settings = ['BearerAuth']  # noqa: E501
 
         _response_types_map = {
-            '200': "GetWallet200Response",
+            '200': "Wallet2",
+            '401': "NotAuthorizedResponse",
+            '404': "NotFoundResponse",
         }
 
         return self.api_client.call_api(
-            '/wallets/{id}', 'GET',
+            '/v1/w3s/wallets/{id}', 'GET',
             _path_params,
             _query_params,
             _header_params,
@@ -358,31 +377,33 @@ class WalletsApi(object):
 
     @auto_fill
     @validate_arguments
-    def list_wallet_ballance(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ListWalletBallance200Response:  # noqa: E501
-        """Get token balance for a wallet  # noqa: E501
+    def get_wallets(self, address : Annotated[Optional[StrictStr], Field(description="Filter by the blockchain address of the wallet.")] = None, blockchain : Annotated[Optional[Blockchain], Field(description="Filter by blockchain.")] = None, wallet_set_id : Annotated[Optional[StrictStr], Field(description="Filter by the wallet set.")] = None, ref_id : Annotated[Optional[StrictStr], Field(description="Filter by the reference identifier.")] = None, var_from : Annotated[Optional[datetime], Field(description="Queries items created since the specified date-time (inclusive) in ISO 8601 format.")] = None, to : Annotated[Optional[datetime], Field(description="Queries items created before the specified date-time (inclusive) in ISO 8601 format.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> Wallets:  # noqa: E501
+        """List wallets  # noqa: E501
 
-        Fetches the digital asset balance for a single developer-controlled wallet using its unique identifier.  # noqa: E501
+        Retrieves a list of all wallets that fit the specified parameters.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.list_wallet_ballance(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
+        >>> thread = api.get_wallets(address, blockchain, wallet_set_id, ref_id, var_from, to, page_before, page_after, page_size, async_req=True)
         >>> result = thread.get()
 
-        :param id: Wallet ID (required)
-        :type id: str
-        :param include_all: Return all recourses with monitored and non-monitored tokens.
-        :type include_all: bool
-        :param name: Filter by token name.
-        :type name: str
-        :param token_address: Filter by token addresses.
-        :type token_address: str
-        :param standard: Filter by the token standard.
-        :type standard: str
-        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. 
+        :param address: Filter by the blockchain address of the wallet.
+        :type address: str
+        :param blockchain: Filter by blockchain.
+        :type blockchain: Blockchain
+        :param wallet_set_id: Filter by the wallet set.
+        :type wallet_set_id: str
+        :param ref_id: Filter by the reference identifier.
+        :type ref_id: str
+        :param var_from: Queries items created since the specified date-time (inclusive) in ISO 8601 format.
+        :type var_from: datetime
+        :param to: Queries items created before the specified date-time (inclusive) in ISO 8601 format.
+        :type to: datetime
+        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. 
         :type page_before: str
-        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. 
+        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. 
         :type page_after: str
-        :param page_size: Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. 
+        :param page_size: Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. 
         :type page_size: int
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -393,40 +414,42 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: ListWalletBallance200Response
+        :rtype: Wallets
         """
         kwargs['_return_http_data_only'] = True
         if '_preload_content' in kwargs:
-            raise ValueError("Error! Please call the list_wallet_ballance_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
-        return self.list_wallet_ballance_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, **kwargs)  # noqa: E501
+            raise ValueError("Error! Please call the get_wallets_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
+        return self.get_wallets_with_http_info(address, blockchain, wallet_set_id, ref_id, var_from, to, page_before, page_after, page_size, **kwargs)  # noqa: E501
 
     @auto_fill
     @validate_arguments
-    def list_wallet_ballance_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """Get token balance for a wallet  # noqa: E501
+    def get_wallets_with_http_info(self, address : Annotated[Optional[StrictStr], Field(description="Filter by the blockchain address of the wallet.")] = None, blockchain : Annotated[Optional[Blockchain], Field(description="Filter by blockchain.")] = None, wallet_set_id : Annotated[Optional[StrictStr], Field(description="Filter by the wallet set.")] = None, ref_id : Annotated[Optional[StrictStr], Field(description="Filter by the reference identifier.")] = None, var_from : Annotated[Optional[datetime], Field(description="Queries items created since the specified date-time (inclusive) in ISO 8601 format.")] = None, to : Annotated[Optional[datetime], Field(description="Queries items created before the specified date-time (inclusive) in ISO 8601 format.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """List wallets  # noqa: E501
 
-        Fetches the digital asset balance for a single developer-controlled wallet using its unique identifier.  # noqa: E501
+        Retrieves a list of all wallets that fit the specified parameters.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.list_wallet_ballance_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
+        >>> thread = api.get_wallets_with_http_info(address, blockchain, wallet_set_id, ref_id, var_from, to, page_before, page_after, page_size, async_req=True)
         >>> result = thread.get()
 
-        :param id: Wallet ID (required)
-        :type id: str
-        :param include_all: Return all recourses with monitored and non-monitored tokens.
-        :type include_all: bool
-        :param name: Filter by token name.
-        :type name: str
-        :param token_address: Filter by token addresses.
-        :type token_address: str
-        :param standard: Filter by the token standard.
-        :type standard: str
-        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. 
+        :param address: Filter by the blockchain address of the wallet.
+        :type address: str
+        :param blockchain: Filter by blockchain.
+        :type blockchain: Blockchain
+        :param wallet_set_id: Filter by the wallet set.
+        :type wallet_set_id: str
+        :param ref_id: Filter by the reference identifier.
+        :type ref_id: str
+        :param var_from: Queries items created since the specified date-time (inclusive) in ISO 8601 format.
+        :type var_from: datetime
+        :param to: Queries items created before the specified date-time (inclusive) in ISO 8601 format.
+        :type to: datetime
+        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. 
         :type page_before: str
-        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. 
+        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. 
         :type page_after: str
-        :param page_size: Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. 
+        :param page_size: Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. 
         :type page_size: int
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -450,17 +473,18 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(ListWalletBallance200Response, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(Wallets, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
         _all_params = [
-            'id',
-            'include_all',
-            'name',
-            'token_address',
-            'standard',
+            'address',
+            'blockchain',
+            'wallet_set_id',
+            'ref_id',
+            'var_from',
+            'to',
             'page_before',
             'page_after',
             'page_size'
@@ -482,7 +506,7 @@ class WalletsApi(object):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_wallet_ballance" % _key
+                    " to method get_wallets" % _key
                 )
             _params[_key] = _val
         del _params['kwargs']
@@ -491,23 +515,32 @@ class WalletsApi(object):
 
         # process the path parameters
         _path_params = {}
-        if _params['id']:
-            _path_params['id'] = _params['id']
-
 
         # process the query parameters
         _query_params = []
-        if _params.get('include_all') is not None:  # noqa: E501
-            _query_params.append(('includeAll', _params['include_all']))
+        if _params.get('address') is not None:  # noqa: E501
+            _query_params.append(('address', _params['address']))
 
-        if _params.get('name') is not None:  # noqa: E501
-            _query_params.append(('name', _params['name']))
+        if _params.get('blockchain') is not None:  # noqa: E501
+            _query_params.append(('blockchain', _params['blockchain'].value))
 
-        if _params.get('token_address') is not None:  # noqa: E501
-            _query_params.append(('tokenAddress', _params['token_address']))
+        if _params.get('wallet_set_id') is not None:  # noqa: E501
+            _query_params.append(('walletSetId', _params['wallet_set_id']))
 
-        if _params.get('standard') is not None:  # noqa: E501
-            _query_params.append(('standard', _params['standard']))
+        if _params.get('ref_id') is not None:  # noqa: E501
+            _query_params.append(('refId', _params['ref_id']))
+
+        if _params.get('var_from') is not None:  # noqa: E501
+            if isinstance(_params['var_from'], datetime):
+                _query_params.append(('from', _params['var_from'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('from', _params['var_from']))
+
+        if _params.get('to') is not None:  # noqa: E501
+            if isinstance(_params['to'], datetime):
+                _query_params.append(('to', _params['to'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('to', _params['to']))
 
         if _params.get('page_before') is not None:  # noqa: E501
             _query_params.append(('pageBefore', _params['page_before']))
@@ -533,11 +566,12 @@ class WalletsApi(object):
         _auth_settings = ['BearerAuth']  # noqa: E501
 
         _response_types_map = {
-            '200': "ListWalletBallance200Response",
+            '200': "Wallets",
+            '401': "NotAuthorizedResponse",
         }
 
         return self.api_client.call_api(
-            '/wallets/{id}/balances', 'GET',
+            '/v1/w3s/wallets', 'GET',
             _path_params,
             _query_params,
             _header_params,
@@ -555,14 +589,14 @@ class WalletsApi(object):
 
     @auto_fill
     @validate_arguments
-    def list_wallet_nfts(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ListWalletNfts200Response:  # noqa: E501
-        """Get NFTs for a wallet  # noqa: E501
+    def list_wallet_ballance(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ListWalletBallance200Response:  # noqa: E501
+        """Get token balance for a wallet  # noqa: E501
 
-        Fetches the info for all NFTs stored in a single developer-controlled wallet, using the wallets unique identifier.  # noqa: E501
+        Fetches the digital asset balance for a single developer-controlled wallet using its unique identifier.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.list_wallet_nfts(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
+        >>> thread = api.list_wallet_ballance(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
         >>> result = thread.get()
 
         :param id: Wallet ID (required)
@@ -575,11 +609,11 @@ class WalletsApi(object):
         :type token_address: str
         :param standard: Filter by the token standard.
         :type standard: str
-        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. 
+        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. 
         :type page_before: str
-        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. 
+        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. 
         :type page_after: str
-        :param page_size: Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. 
+        :param page_size: Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. 
         :type page_size: int
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -590,23 +624,23 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: ListWalletNfts200Response
+        :rtype: ListWalletBallance200Response
         """
         kwargs['_return_http_data_only'] = True
         if '_preload_content' in kwargs:
-            raise ValueError("Error! Please call the list_wallet_nfts_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
-        return self.list_wallet_nfts_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, **kwargs)  # noqa: E501
+            raise ValueError("Error! Please call the list_wallet_ballance_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
+        return self.list_wallet_ballance_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, **kwargs)  # noqa: E501
 
     @auto_fill
     @validate_arguments
-    def list_wallet_nfts_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """Get NFTs for a wallet  # noqa: E501
+    def list_wallet_ballance_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """Get token balance for a wallet  # noqa: E501
 
-        Fetches the info for all NFTs stored in a single developer-controlled wallet, using the wallets unique identifier.  # noqa: E501
+        Fetches the digital asset balance for a single developer-controlled wallet using its unique identifier.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.list_wallet_nfts_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
+        >>> thread = api.list_wallet_ballance_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
         >>> result = thread.get()
 
         :param id: Wallet ID (required)
@@ -619,11 +653,11 @@ class WalletsApi(object):
         :type token_address: str
         :param standard: Filter by the token standard.
         :type standard: str
-        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. 
+        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. 
         :type page_before: str
-        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. 
+        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. 
         :type page_after: str
-        :param page_size: Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. 
+        :param page_size: Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. 
         :type page_size: int
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -647,7 +681,7 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(ListWalletNfts200Response, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(ListWalletBallance200Response, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
@@ -679,7 +713,7 @@ class WalletsApi(object):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_wallet_nfts" % _key
+                    " to method list_wallet_ballance" % _key
                 )
             _params[_key] = _val
         del _params['kwargs']
@@ -730,11 +764,11 @@ class WalletsApi(object):
         _auth_settings = ['BearerAuth']  # noqa: E501
 
         _response_types_map = {
-            '200': "ListWalletNfts200Response",
+            '200': "ListWalletBallance200Response",
         }
 
         return self.api_client.call_api(
-            '/wallets/{id}/nfts', 'GET',
+            '/v1/w3s/wallets/{id}/balances', 'GET',
             _path_params,
             _query_params,
             _header_params,
@@ -752,33 +786,31 @@ class WalletsApi(object):
 
     @auto_fill
     @validate_arguments
-    def list_wallets(self, address : Annotated[Optional[StrictStr], Field(description="Filter by the Address of the wallet.")] = None, blockchain : Annotated[Optional[StrictStr], Field(description="Filter by blockchain.")] = None, wallet_set_id : Annotated[Optional[StrictStr], Field(description="Filter by the wallet set the wallet belongs to.")] = None, ref_id : Annotated[Optional[StrictStr], Field(description="Filter by the reference identifier set on the wallet.")] = None, var_from : Annotated[Optional[datetime], Field(description="Queries items created since the specified date-time (inclusive) in ISO 8601 format.")] = None, to : Annotated[Optional[datetime], Field(description="Queries items created before the specified date-time (inclusive) in ISO 8601 format.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ListWallets200Response:  # noqa: E501
-        """List wallets  # noqa: E501
+    def list_wallet_nfts(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ListWalletNfts200Response:  # noqa: E501
+        """Get NFTs for a wallet  # noqa: E501
 
-        Retrieves a list of all developer-controlled wallets that fit the specified parameters.  # noqa: E501
+        Fetches the info for all NFTs stored in a single developer-controlled wallet, using the wallets unique identifier.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.list_wallets(address, blockchain, wallet_set_id, ref_id, var_from, to, page_before, page_after, page_size, async_req=True)
+        >>> thread = api.list_wallet_nfts(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
         >>> result = thread.get()
 
-        :param address: Filter by the Address of the wallet.
-        :type address: str
-        :param blockchain: Filter by blockchain.
-        :type blockchain: str
-        :param wallet_set_id: Filter by the wallet set the wallet belongs to.
-        :type wallet_set_id: str
-        :param ref_id: Filter by the reference identifier set on the wallet.
-        :type ref_id: str
-        :param var_from: Queries items created since the specified date-time (inclusive) in ISO 8601 format.
-        :type var_from: datetime
-        :param to: Queries items created before the specified date-time (inclusive) in ISO 8601 format.
-        :type to: datetime
-        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. 
+        :param id: Wallet ID (required)
+        :type id: str
+        :param include_all: Return all recourses with monitored and non-monitored tokens.
+        :type include_all: bool
+        :param name: Filter by token name.
+        :type name: str
+        :param token_address: Filter by token addresses.
+        :type token_address: str
+        :param standard: Filter by the token standard.
+        :type standard: str
+        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. 
         :type page_before: str
-        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. 
+        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. 
         :type page_after: str
-        :param page_size: Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. 
+        :param page_size: Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. 
         :type page_size: int
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -789,42 +821,40 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: ListWallets200Response
+        :rtype: ListWalletNfts200Response
         """
         kwargs['_return_http_data_only'] = True
         if '_preload_content' in kwargs:
-            raise ValueError("Error! Please call the list_wallets_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
-        return self.list_wallets_with_http_info(address, blockchain, wallet_set_id, ref_id, var_from, to, page_before, page_after, page_size, **kwargs)  # noqa: E501
+            raise ValueError("Error! Please call the list_wallet_nfts_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
+        return self.list_wallet_nfts_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, **kwargs)  # noqa: E501
 
     @auto_fill
     @validate_arguments
-    def list_wallets_with_http_info(self, address : Annotated[Optional[StrictStr], Field(description="Filter by the Address of the wallet.")] = None, blockchain : Annotated[Optional[StrictStr], Field(description="Filter by blockchain.")] = None, wallet_set_id : Annotated[Optional[StrictStr], Field(description="Filter by the wallet set the wallet belongs to.")] = None, ref_id : Annotated[Optional[StrictStr], Field(description="Filter by the reference identifier set on the wallet.")] = None, var_from : Annotated[Optional[datetime], Field(description="Queries items created since the specified date-time (inclusive) in ISO 8601 format.")] = None, to : Annotated[Optional[datetime], Field(description="Queries items created before the specified date-time (inclusive) in ISO 8601 format.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """List wallets  # noqa: E501
+    def list_wallet_nfts_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], include_all : Annotated[Optional[StrictBool], Field(description="Return all recourses with monitored and non-monitored tokens.")] = None, name : Annotated[Optional[StrictStr], Field(description="Filter by token name.")] = None, token_address : Annotated[Optional[StrictStr], Field(description="Filter by token addresses.")] = None, standard : Annotated[Optional[StrictStr], Field(description="Filter by the token standard.")] = None, page_before : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. ")] = None, page_after : Annotated[Optional[StrictStr], Field(description="A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. ")] = None, page_size : Annotated[Optional[conint(strict=True, le=50, ge=1)], Field(description="Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. ")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """Get NFTs for a wallet  # noqa: E501
 
-        Retrieves a list of all developer-controlled wallets that fit the specified parameters.  # noqa: E501
+        Fetches the info for all NFTs stored in a single developer-controlled wallet, using the wallets unique identifier.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.list_wallets_with_http_info(address, blockchain, wallet_set_id, ref_id, var_from, to, page_before, page_after, page_size, async_req=True)
+        >>> thread = api.list_wallet_nfts_with_http_info(id, include_all, name, token_address, standard, page_before, page_after, page_size, async_req=True)
         >>> result = thread.get()
 
-        :param address: Filter by the Address of the wallet.
-        :type address: str
-        :param blockchain: Filter by blockchain.
-        :type blockchain: str
-        :param wallet_set_id: Filter by the wallet set the wallet belongs to.
-        :type wallet_set_id: str
-        :param ref_id: Filter by the reference identifier set on the wallet.
-        :type ref_id: str
-        :param var_from: Queries items created since the specified date-time (inclusive) in ISO 8601 format.
-        :type var_from: datetime
-        :param to: Queries items created before the specified date-time (inclusive) in ISO 8601 format.
-        :type to: datetime
-        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjuction with pageAfter. 
+        :param id: Wallet ID (required)
+        :type id: str
+        :param include_all: Return all recourses with monitored and non-monitored tokens.
+        :type include_all: bool
+        :param name: Filter by token name.
+        :type name: str
+        :param token_address: Filter by token addresses.
+        :type token_address: str
+        :param standard: Filter by the token standard.
+        :type standard: str
+        :param page_before: A collection ID value used for pagination.  It marks the exclusive end of a page. When provided, the collection resource will return the next n items before the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.   SHOULD NOT be used in conjunction with pageAfter. 
         :type page_before: str
-        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjuction with pageBefore. 
+        :param page_after: A collection ID value used for pagination.  It marks the exclusive begin of a page. When provided, the collection resource will return the next n items after the id, with n being specified by pageSize.  The items will be returned in the natural order of the collection.  The resource will return the first page if neither pageAfter nor pageBefore are specified.  SHOULD NOT be used in conjunction with pageBefore. 
         :type page_after: str
-        :param page_size: Limits the number of items to be returned.   Some collections have a strict upper bound that will disregard this value. In case the specified value is higher  than the allowed limit, the collection limit will be used.   If avoided, the collection will determine the page size itself. 
+        :param page_size: Limits the number of items to be returned.  Some collections have a strict upper bound that will disregard this value. In case the specified value is higher than the allowed limit, the collection limit will be used.  If avoided, the collection will determine the page size itself. 
         :type page_size: int
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -848,18 +878,17 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(ListWallets200Response, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(ListWalletNfts200Response, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
         _all_params = [
-            'address',
-            'blockchain',
-            'wallet_set_id',
-            'ref_id',
-            'var_from',
-            'to',
+            'id',
+            'include_all',
+            'name',
+            'token_address',
+            'standard',
             'page_before',
             'page_after',
             'page_size'
@@ -881,7 +910,7 @@ class WalletsApi(object):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_wallets" % _key
+                    " to method list_wallet_nfts" % _key
                 )
             _params[_key] = _val
         del _params['kwargs']
@@ -890,32 +919,23 @@ class WalletsApi(object):
 
         # process the path parameters
         _path_params = {}
+        if _params['id']:
+            _path_params['id'] = _params['id']
+
 
         # process the query parameters
         _query_params = []
-        if _params.get('address') is not None:  # noqa: E501
-            _query_params.append(('address', _params['address']))
-
-        if _params.get('blockchain') is not None:  # noqa: E501
-            _query_params.append(('blockchain', _params['blockchain']))
-
-        if _params.get('wallet_set_id') is not None:  # noqa: E501
-            _query_params.append(('walletSetId', _params['wallet_set_id']))
+        if _params.get('include_all') is not None:  # noqa: E501
+            _query_params.append(('includeAll', _params['include_all']))
 
-        if _params.get('ref_id') is not None:  # noqa: E501
-            _query_params.append(('refId', _params['ref_id']))
+        if _params.get('name') is not None:  # noqa: E501
+            _query_params.append(('name', _params['name']))
 
-        if _params.get('var_from') is not None:  # noqa: E501
-            if isinstance(_params['var_from'], datetime):
-                _query_params.append(('from', _params['var_from'].strftime(self.api_client.configuration.datetime_format)))
-            else:
-                _query_params.append(('from', _params['var_from']))
+        if _params.get('token_address') is not None:  # noqa: E501
+            _query_params.append(('tokenAddress', _params['token_address']))
 
-        if _params.get('to') is not None:  # noqa: E501
-            if isinstance(_params['to'], datetime):
-                _query_params.append(('to', _params['to'].strftime(self.api_client.configuration.datetime_format)))
-            else:
-                _query_params.append(('to', _params['to']))
+        if _params.get('standard') is not None:  # noqa: E501
+            _query_params.append(('standard', _params['standard']))
 
         if _params.get('page_before') is not None:  # noqa: E501
             _query_params.append(('pageBefore', _params['page_before']))
@@ -941,11 +961,11 @@ class WalletsApi(object):
         _auth_settings = ['BearerAuth']  # noqa: E501
 
         _response_types_map = {
-            '200': "ListWallets200Response",
+            '200': "ListWalletNfts200Response",
         }
 
         return self.api_client.call_api(
-            '/wallets', 'GET',
+            '/v1/w3s/wallets/{id}/nfts', 'GET',
             _path_params,
             _query_params,
             _header_params,
@@ -963,20 +983,22 @@ class WalletsApi(object):
 
     @auto_fill
     @validate_arguments
-    def update_wallet(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], ext_update_wallet_metadata_request : Annotated[ExtUpdateWalletMetadataRequest, Field(..., description="Wallet metadata update request")], **kwargs) -> UpdateWallet200Response:  # noqa: E501
+    def update_wallet(self, id : Annotated[StrictStr, Field(..., description="The universally unique identifier (UUID v4) of the resource.")], update_wallet_request : Annotated[UpdateWalletRequest, Field(..., description="Schema for the request payload to update an existing wallet.")], x_request_id : Annotated[Optional[StrictStr], Field(description="Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.")] = None, **kwargs) -> Wallet2:  # noqa: E501
         """Update a wallet  # noqa: E501
 
-        Updates info for a single developer-controlled wallet using it's unique identifier.  # noqa: E501
+        Updates info metadata of a wallet.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.update_wallet(id, ext_update_wallet_metadata_request, async_req=True)
+        >>> thread = api.update_wallet(id, update_wallet_request, x_request_id, async_req=True)
         >>> result = thread.get()
 
-        :param id: Wallet ID (required)
+        :param id: The universally unique identifier (UUID v4) of the resource. (required)
         :type id: str
-        :param ext_update_wallet_metadata_request: Wallet metadata update request (required)
-        :type ext_update_wallet_metadata_request: ExtUpdateWalletMetadataRequest
+        :param update_wallet_request: Schema for the request payload to update an existing wallet. (required)
+        :type update_wallet_request: UpdateWalletRequest
+        :param x_request_id: Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.
+        :type x_request_id: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: timeout setting for this request. If one
@@ -986,29 +1008,31 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: UpdateWallet200Response
+        :rtype: Wallet2
         """
         kwargs['_return_http_data_only'] = True
         if '_preload_content' in kwargs:
             raise ValueError("Error! Please call the update_wallet_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
-        return self.update_wallet_with_http_info(id, ext_update_wallet_metadata_request, **kwargs)  # noqa: E501
+        return self.update_wallet_with_http_info(id, update_wallet_request, x_request_id, **kwargs)  # noqa: E501
 
     @auto_fill
     @validate_arguments
-    def update_wallet_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Wallet ID")], ext_update_wallet_metadata_request : Annotated[ExtUpdateWalletMetadataRequest, Field(..., description="Wallet metadata update request")], **kwargs) -> ApiResponse:  # noqa: E501
+    def update_wallet_with_http_info(self, id : Annotated[StrictStr, Field(..., description="The universally unique identifier (UUID v4) of the resource.")], update_wallet_request : Annotated[UpdateWalletRequest, Field(..., description="Schema for the request payload to update an existing wallet.")], x_request_id : Annotated[Optional[StrictStr], Field(description="Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """Update a wallet  # noqa: E501
 
-        Updates info for a single developer-controlled wallet using it's unique identifier.  # noqa: E501
+        Updates info metadata of a wallet.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.update_wallet_with_http_info(id, ext_update_wallet_metadata_request, async_req=True)
+        >>> thread = api.update_wallet_with_http_info(id, update_wallet_request, x_request_id, async_req=True)
         >>> result = thread.get()
 
-        :param id: Wallet ID (required)
+        :param id: The universally unique identifier (UUID v4) of the resource. (required)
         :type id: str
-        :param ext_update_wallet_metadata_request: Wallet metadata update request (required)
-        :type ext_update_wallet_metadata_request: ExtUpdateWalletMetadataRequest
+        :param update_wallet_request: Schema for the request payload to update an existing wallet. (required)
+        :type update_wallet_request: UpdateWalletRequest
+        :param x_request_id: Developer-provided parameter used to identify this request. Useful when communicating with Circle Support.
+        :type x_request_id: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -1031,14 +1055,15 @@ class WalletsApi(object):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(UpdateWallet200Response, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(Wallet2, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
         _all_params = [
             'id',
-            'ext_update_wallet_metadata_request'
+            'update_wallet_request',
+            'x_request_id'
         ]
         _all_params.extend(
             [
@@ -1074,13 +1099,16 @@ class WalletsApi(object):
         _query_params = []
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
+        if _params['x_request_id']:
+            _header_params['X-Request-Id'] = _params['x_request_id']
+
         # process the form parameters
         _form_params = []
         _files = {}
         # process the body parameter
         _body_params = None
-        if _params['ext_update_wallet_metadata_request'] is not None:
-            _body_params = _params['ext_update_wallet_metadata_request']
+        if _params['update_wallet_request'] is not None:
+            _body_params = _params['update_wallet_request']
 
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(
@@ -1097,11 +1125,14 @@ class WalletsApi(object):
         _auth_settings = ['BearerAuth']  # noqa: E501
 
         _response_types_map = {
-            '200': "UpdateWallet200Response",
+            '200': "Wallet2",
+            '400': "BadRequestResponse",
+            '401': "NotAuthorizedResponse",
+            '404': "NotFoundResponse",
         }
 
         return self.api_client.call_api(
-            '/wallets/{id}', 'PUT',
+            '/v1/w3s/wallets/{id}', 'PUT',
             _path_params,
             _query_params,
             _header_params,